sabiql 3.0.1

Fast, safe-by-design, Vim-first DB TUI with ER diagrams
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#!/usr/bin/env ruby
# frozen_string_literal: true

require "minitest/autorun"
require "open3"
require "rbconfig"
require "tmpdir"

SCRIPT = File.expand_path("lint_test_names.rb", __dir__)

class LintTestNamesTest < Minitest::Test
  def run_lint(source)
    Dir.mktmpdir do |directory|
      path = File.join(directory, "fixture.rs")
      File.write(path, source)
      return Open3.capture3(RbConfig.ruby, SCRIPT, path)
    end
  end

  def test_allows_test_only_items_inside_test_modules
    stdout, stderr, status = run_lint(<<~RUST)
      #[cfg(test)]
      mod tests {
          #[cfg(test)]
          fn helper() {}

          #[cfg(test)]
          struct Fixture;

          #[cfg(test)]
          impl Fixture {}

          #[cfg(test)]
          const VALUE: usize = 1;

          #[cfg(test)]
          type Alias = usize;

          #[cfg(test)]
          static SHARED: usize = 1;
      }

      #[cfg(feature = "test-support")]
      fn test_support_helper() {}
    RUST

    assert status.success?, stderr
    assert_equal "test-name lint passed\n", stdout
    assert_empty stderr
  end

  def test_rejects_test_only_items_at_module_scope
    _stdout, stderr, status = run_lint(<<~RUST)
      #[cfg(test)]
      fn misplaced_function() {}

      #[cfg(test)]
      extern "C" fn misplaced_extern_function() {}

      #[cfg(test)]
      async unsafe fn misplaced_async_unsafe_function() {}

      #[cfg(test)]
      struct MisplacedStruct;

      #[cfg(test)]
      impl MisplacedStruct {}

      #[cfg(test)]
      const MISPLACED_CONST: usize = 1;

      #[cfg(test)]
      type MisplacedType = usize;

      #[cfg(test)]
      static MISPLACED_STATIC: usize = 1;

      mod production {
          #[cfg(test)]
          fn nested_function() {}
      }
    RUST

    refute status.success?
    assert_equal 9, stderr.lines.grep(/test-only item must be inside a cfg\(test\) module/).length
    assert_includes stderr, "fixture.rs"
  end

  def test_keeps_stacked_attributes_and_test_module_scope_distinct
    _stdout, stderr, status = run_lint(<<~RUST)
      #[cfg(test)]
      #[allow(dead_code)]
      fn misplaced_function() {}

      #[cfg(test)]
      mod tests {
          #[cfg(test)]
          #[allow(dead_code)]
          fn helper() {}
      }
    RUST

    refute status.success?
    assert_equal 1, stderr.lines.grep(/test-only item must be inside a cfg\(test\) module/).length
  end

  def test_allows_stacked_test_use_tree_inside_test_module
    stdout, stderr, status = run_lint(<<~RUST)
      #[cfg(test)]
      mod tests {
          #[cfg(test)]
          #[allow(unused_imports)]
          use crate::{
              Fixture,
              OtherFixture,
          };
      }

      #[cfg(any(test, feature = "test-support"))]
      use crate::SharedFixture;

      #[cfg(feature = "test-support")]
      use crate::FeatureFixture;
    RUST

    assert status.success?, stderr
    assert_equal "test-name lint passed\n", stdout
    assert_empty stderr
  end

  def test_rejects_private_test_use_at_module_scope
    _stdout, stderr, status = run_lint(<<~RUST)
      #[cfg(test)]
      #[allow(unused_imports)]
      use crate::Fixture;

      #[cfg(test)]
      use crate::{
          FirstFixture,
          SecondFixture,
      };

      mod production {
          #[cfg(test)]
          use crate::NestedFixture;
      }
    RUST

    refute status.success?
    assert_equal 3, stderr.lines.grep(/test-only use must be inside a cfg\(test\) module/).length
  end
end