conjure_shield 0.1.0

data/lib/conjure_shield/analyzer.rb

@@ -0,0 +1,762 @@
+require "prism"
+require "rubocop"
+require "rubocop-rails"
+require "rubocop-rspec"
+require "open3"
+
+module ConjureShield
+  class Analyzer
+    RESTFUL_ACTIONS = %i[index show new create edit update destroy].freeze
+    SINGULAR_ACTIONS = %i[show new create edit update destroy].freeze
+
+    ACTION_ROUTE_MAP = {
+      index: [:get_index, :index_pagination, :index_sorting],
+      show: [:get_show, :show_with_associations],
+      new: [:get_new, :new_form],
+      create: [:post_create, :post_create_valid, :post_create_invalid, :post_create_redirect],
+      edit: [:get_edit, :edit_form],
+      update: [:put_patch_update_valid, :put_patch_update_invalid, :put_patch_update_redirect],
+      destroy: [:delete_destroy, :delete_destroy_redirect]
+    }.freeze
+
+    attr_reader :codebase_path, :files, :ast_nodes, :missing_tests, :existing_tests, :routes, :routes_parsed, :devise_model
+
+    def initialize(path)
+      @codebase_path = File.expand_path(path)
+      @ast_nodes = []
+      @missing_tests = []
+      @existing_tests = []
+      @files = []
+      @routes = {}
+      @routes_parsed = false
+      @devise_model = nil
+    end
+
+    def analyze
+      scan_ruby_files
+      scan_existing_tests
+      analyze_ast
+      parse_routes
+      detect_missing_tests
+      self
+    end
+
+    private
+
+    def scan_ruby_files
+      Dir.glob("#{codebase_path}/**/*.rb").each do |file|
+        next if file.include?("/vendor/") || file.include?("/node_modules/")
+        next if file.include?("/test/") || file.include?("/spec/")
+        next if file.include?("/db/") || file.include?("/config/")
+
+        content = File.read(file)
+        @files << { path: file, content: content }
+        parse_file(file, content)
+      end
+
+      Dir.glob("#{codebase_path}/**/*_controller.js").each do |file|
+        next if file.include?("/node_modules/") || file.include?("/vendor/")
+
+        content = File.read(file)
+        extract_stimulus(file, content)
+      end
+    end
+
+    def parse_file(file, content)
+      begin
+        ast = Prism.parse(content).value
+        @ast_nodes << { file: file, ast: ast, content: content }
+        extract_model_info(file, ast)
+        extract_controller_info(file, ast)
+        extract_serializer_info(file, ast)
+        extract_helper_methods(file, ast)
+        extract_callbacks(file, ast)
+        extract_scopes(file, ast)
+        extract_validations(file, ast)
+        extract_associations(file, ast)
+        extract_custom_methods(file, ast)
+        extract_factories(file, content)
+        extract_serialization(file, content)
+        extract_delegation(file, ast)
+        extract_cable_subscriptions(file, content)
+        extract_cable_broadcasts(file, content)
+        extract_describe_blocks(file, content)
+      rescue Prism::ParseError => e
+        warn "Parse error in #{file}: #{e.message}"
+      end
+    end
+
+    def scan_existing_tests
+      # Look for both RSpec and Minitest structures safely
+      Dir.glob("#{codebase_path}/{spec,test}/**/*_{spec,test}.rb").each do |file|
+        next if file.include?("/vendor/") || file.include?("/node_modules/")
+
+        @existing_tests << {
+          file: file,
+          filename: File.basename(file)
+        }
+      end
+    end
+
+    def analyze_ast
+      # Gather all granular metadata fragments found by your visitors
+      metadata_nodes = @ast_nodes.select do |n| 
+        [:callbacks, :validations, :scopes, :associations, :custom_methods, :delegation].include?(n[:type]) 
+      end
+      
+      # Find the primary component definitions
+      primary_components = @ast_nodes.select { |n| [:model, :controller, :serializer, :helper].include?(n[:type]) }
+
+      # Cross-reference and enrich the primary components with their specific features
+      # This keeps @ast_nodes flat so your CLI counters still work!
+      primary_components.each do |component|
+        component[:metadata] ||= {}
+        
+        file_metadata = metadata_nodes.select { |meta| meta[:file] == component[:file] }
+        file_metadata.each do |meta|
+          payload_key = meta[:type]
+          component[:metadata][payload_key] = meta[payload_key] || meta[:methods] || meta[:delegations]
+        end
+      end
+    end
+
+    def extract_model_info(file, ast)
+      return unless file.include?("/app/models/")
+
+      content = @files.find { |f| f[:path] == file }&.dig(:content) || ""
+      model_name = model_name_from_path(file)
+
+      @devise_model ||= model_name if content.include?("devise")
+
+      @ast_nodes << { file: file, model: model_name, type: :model }
+    end
+
+    def model_name_from_path(path)
+      relative = path.sub(%r{.*/app/[^/]+/}, "").sub(/\.rb\z/, "")
+      relative.split("/").map { |part| part.split("_").map(&:capitalize).join }.join("::")
+    end
+
+    def extract_controller_info(file, ast)
+      return unless file.include?("/app/controllers/")
+
+      controller_name = model_name_from_path(file)
+      @ast_nodes << { file: file, controller: controller_name, type: :controller }
+    end
+
+    def extract_serializer_info(file, ast)
+      return unless file.include?("/app/serializers/")
+      
+      serializer_name = File.basename(file, ".rb").split('_').map(&:capitalize).join
+      @ast_nodes << { file: file, serializer: serializer_name, type: :serializer }
+    end
+
+    def extract_helper_methods(file, ast)
+      return unless File.basename(file).include?("_helper")
+
+      @ast_nodes << { file: file, type: :helper }
+    end
+
+    def extract_callbacks(file, ast)
+      visitor = Class.new(Prism::Visitor) do
+        attr_reader :callbacks
+
+        def initialize
+          @callbacks = []
+          @targets = [:before_save, :after_save, :before_create, :after_create,
+                      :before_update, :after_update, :before_destroy, :after_destroy,
+                      :before_validation, :after_validation, :around_save, :around_create]
+        end
+
+        def visit_call_node(node)
+          @callbacks << node.name if @targets.include?(node.name)
+          super
+        end
+      end.new
+
+      visitor.visit(ast)
+      return if visitor.callbacks.empty?
+
+      @ast_nodes << { file: file, callbacks: visitor.callbacks, type: :callbacks }
+    end
+
+    def extract_scopes(file, ast)
+      visitor = Class.new(Prism::Visitor) do
+        attr_reader :scopes
+
+        def initialize
+          @scopes = []
+        end
+
+        def visit_call_node(node)
+          if node.name == :scope && node.arguments&.arguments&.any?
+            arg = node.arguments.arguments.first
+            name = if arg.is_a?(Prism::StringNode)
+                     arg.content
+                   elsif arg.is_a?(Prism::SymbolNode)
+                     arg.value
+                   end
+            @scopes << { name: name, args: [] } if name
+          end
+          super
+        end
+      end.new
+
+      visitor.visit(ast)
+      return if visitor.scopes.empty?
+
+      @ast_nodes << { file: file, scopes: visitor.scopes, type: :scopes }
+    end
+
+    def extract_validations(file, ast)
+      content = @files.find { |f| f[:path] == file }&.dig(:content) || ""
+      validations = []
+
+      content.each_line do |line|
+        next unless line =~ /validates\s+(?::)?(\w[\w!?]*)/
+
+        field = $1
+        validators = []
+        validators << :presence if line.include?("presence:")
+        validators << :uniqueness if line.include?("uniqueness:")
+        validators << :length if line.include?("length:")
+        validators << :format if line.include?("format:")
+        validators << :inclusion if line.include?("inclusion:")
+        validators << :exclusion if line.include?("exclusion:")
+        validators << :confirmation if line.include?("confirmation:")
+        validators << :acceptance if line.include?("acceptance:")
+        validators << :numericality if line.include?("numericality:")
+        validators << :comparison if line.include?("comparison:")
+
+        validations << { field: field, validators: validators }
+      end
+
+      return if validations.empty?
+
+      @ast_nodes << { file: file, validations: validations, type: :validations }
+    end
+
+    def extract_associations(file, ast)
+      visitor = Class.new(Prism::Visitor) do
+        attr_reader :associations
+
+        def initialize
+          @associations = []
+          @targets = [:belongs_to, :has_many, :has_one, :has_and_belongs_to_many,
+                      :has_many_through, :has_one_through]
+        end
+
+        def visit_call_node(node)
+          if @targets.include?(node.name)
+            name = nil
+            if node.arguments&.arguments&.first
+              arg = node.arguments.arguments.first
+              name = arg.value.to_s if arg.respond_to?(:value)
+            end
+            target = name.classify
+            @associations << { type: node.name, name: name, target: target }
+          end
+          super
+        end
+      end.new
+
+      visitor.visit(ast)
+      return if visitor.associations.empty?
+
+      @ast_nodes << { file: file, associations: visitor.associations, type: :associations }
+    end
+
+    def extract_custom_methods(file, ast)
+      visitor = Class.new(Prism::Visitor) do
+        attr_reader :methods
+
+        def initialize
+          @methods = []
+          @ignored = [:initialize, :to_json, :to_yaml, :inspect, :class, :new, :attr_accessor,
+                      :attr_reader, :attr_writer, :attr, :attr_readonly]
+        end
+
+        def visit_def_node(node)
+          unless @ignored.include?(node.name)
+            is_class_method = node.receiver.is_a?(Prism::SelfNode)
+            @methods << { name: node.name, class_method: is_class_method }
+          end
+          super
+        end
+      end.new
+
+      visitor.visit(ast)
+      return if visitor.methods.empty?
+
+      @ast_nodes << { file: file, methods: visitor.methods, type: :custom_methods }
+    end
+
+    def extract_factories(file, content)
+      return unless file.include?("factories") || file.include?("factory")
+
+      @ast_nodes << { file: file, type: :factory }
+    end
+
+    def extract_serialization(file, content)
+      return unless content.include?("to_json") || content.include?("to_yaml")
+
+      @ast_nodes << { file: file, type: :serialization }
+    end
+
+    def extract_delegation(file, ast)
+      visitor = Class.new(Prism::Visitor) do
+        attr_reader :delegations
+
+        def initialize
+          @delegations = []
+        end
+
+        def visit_call_node(node)
+          @delegations << node.name if node.name == :delegate
+          super
+        end
+      end.new
+
+      visitor.visit(ast)
+      return if visitor.delegations.empty?
+
+      @ast_nodes << { file: file, delegations: visitor.delegations, type: :delegation }
+    end
+
+    def extract_stimulus(file, content)
+      return unless file.end_with?("_controller.js")
+
+      controller_name = file.match(/(\w+)_controller\.js\z/)&.[](1)
+      return unless controller_name
+
+      info = { file: file, controller: controller_name, type: :stimulus }
+
+      if content =~ /static\s+targets\s*=\s*\[([^\]]*)\]/
+        info[:targets] = $1.split(",").map { |t| t.strip.gsub(/["'\s]/, "") }.reject(&:empty?)
+      end
+
+      if content =~ /static\s+values\s*=\s*\{(.*?)\}/m
+        info[:values] = {}
+        $1.scan(/(\w+)\s*:\s*(\w+)/) { info[:values][$1] = $2 }
+      end
+
+      if content =~ /static\s+classes\s*=\s*\[([^\]]*)\]/
+        info[:classes] = $1.split(",").map { |t| t.strip.gsub(/["'\s]/, "") }.reject(&:empty?)
+      end
+
+      lifecycle = %w[connect disconnect initialize export default class extends static get set constructor]
+      info[:actions] = content.scan(/^\s+(\w+)\s*\(/).flatten - lifecycle
+
+      @ast_nodes << info
+    end
+
+    def extract_cable_subscriptions(file, content)
+      subscriptions = []
+      content.scan(/subscribe\s*\(\s*["'](?<sub>[^"]+)["']\s*,\s*["'](?<channel>[^"]+)["']/).each do |match|
+        subscriptions << { subscription: match[:sub], channel: match[:channel] }
+      end
+      content.scan(/stream_from\s+(?::)?["']?(\w[\w\/]*)["'#]/).each do |match|
+        subscriptions << { subscription: "stream_from", channel: match[0] }
+      end
+
+      match = file.match(%r{/channels/(\w+)_channel\.rb\z})
+      channel_name = "#{match[1].camelize}Channel" if match
+      if channel_name && subscriptions.any?
+        subscriptions.each { |s| s[:channel] = channel_name }
+      end
+
+      return if subscriptions.empty?
+
+      @ast_nodes << { file: file, subscriptions: subscriptions, type: :cable_subscription }
+    end
+
+    def extract_cable_broadcasts(file, content)
+      channels = []
+      content.scan(/broadcast_to\s*\(\s*["'](?<channel>[^"']+)["']/).each do |match|
+        channels << match[:channel]
+      end
+      content.scan(/ActionCable\.server\.broadcast\s*\(\s*["']?(\w[\w\/]*)["'#]/).each do |match|
+        channels << match[0]
+      end
+
+      match = file.match(%r{/channels/(\w+)_channel\.rb\z})
+      channel_name = "#{match[1].camelize}Channel" if match
+      channels.map! { |_| channel_name } if channel_name && channels.any?
+
+      return if channels.empty?
+
+      @ast_nodes << { file: file, channels: channels, type: :cable_broadcast }
+    end
+
+    def extract_describe_blocks(file, content)
+      blocks = []
+      content.scan(/RSpec\.describe\s+\["?([^"\]]+)"/).each do |match|
+        blocks << { name: match[0], suggestions: [] }
+      end
+      blocks
+    end
+
+    def parse_routes
+      routes_file = File.join(@codebase_path, "config", "routes.rb")
+      return unless File.exist?(routes_file)
+      return if @routes_parsed
+
+      if parse_routes_via_rails_command
+        @routes_parsed = true
+        return
+      end
+
+      content = File.read(routes_file)
+      parse_routes_via_regex(content)
+      @routes_parsed = true
+    end
+
+    def parse_routes_via_rails_command
+      stdout, _, status = Open3.capture3(
+        "bundle", "exec", "rails", "routes",
+        chdir: @codebase_path
+      )
+      return false unless status.success?
+
+      stdout.each_line do |line|
+        stripped = line.strip
+        next if stripped.empty?
+        next if stripped.include?("Controller#Action")
+
+        if stripped =~ /([a-z_][a-z0-9_\/]*)#([a-z_]+)\s*\z/
+          controller_path = $1
+          action = $2.to_sym
+          controller_parts = controller_path.split("/").map(&:camelize)
+          controller_class = controller_parts.join("::") + "Controller"
+          register_controller_routes(controller_class, [action])
+        end
+      end
+
+      true
+    rescue => e
+      warn "rails routes command failed: #{e.message}"
+      false
+    end
+
+    def parse_routes_via_regex(content)
+      prefix_stack = []
+
+      content.each_line do |line|
+        stripped = line.strip
+        next if stripped.empty? || stripped.start_with?("#")
+
+        if stripped =~ /\Aend\b/
+          prefix_stack.pop
+          next
+        end
+
+        if stripped =~ /\bnamespace\s+(?::|["'])(\w+)["']?\s+do\b/
+          prefix_stack << $1.camelize
+          next
+        end
+
+        if stripped =~ /\bscope\s+module:\s*(?::|["'])(\w+)["']?\s+do\b/
+          prefix_stack << $1.camelize
+          next
+        end
+
+        prefix = prefix_stack.any? ? prefix_stack.join("::") + "::" : ""
+
+        if stripped =~ /\bresources\s+(?::|["'])(\w+)["']?/
+          resource_name = $1
+          controller = "#{prefix}#{resource_name.camelize}Controller"
+          actions = parse_route_options(stripped, RESTFUL_ACTIONS)
+          param = stripped.match(/param:\s*(?::|["'])(\w+)["']?\s*/) && $1
+          register_controller_routes(controller, actions, param: param)
+          next
+        end
+
+        if stripped =~ /\bresource\s+(?::|["'])(\w+)["']?/
+          resource_name = $1
+          controller = "#{prefix}#{resource_name.camelize}Controller"
+          actions = parse_route_options(stripped, SINGULAR_ACTIONS)
+          register_controller_routes(controller, actions)
+          next
+        end
+
+        if stripped =~ /\b(get|post|put|patch|delete|match)\s+["'].*?["'].*\bto:\s*["']([a-z_\/]+)#(\w+)["']/
+          controller_parts = $2.split("/").map(&:camelize)
+          controller = "#{prefix}#{controller_parts.join("::")}Controller"
+          register_controller_routes(controller, [$3.to_sym])
+          next
+        end
+
+        if stripped =~ /\b(get|post|put|patch|delete|match)\s+["'].*?["']\s*=>\s*["']([a-z_\/]+)#(\w+)["']/
+          controller_parts = $2.split("/").map(&:camelize)
+          controller = "#{prefix}#{controller_parts.join("::")}Controller"
+          register_controller_routes(controller, [$3.to_sym])
+          next
+        end
+      end
+    end
+
+    def parse_route_options(rest, default_actions)
+      if rest =~ /only:\s*\[([^\]]*)\]/
+        $1.split(",").map { |s| s.strip.gsub(/[":\[\]']/, "").to_sym } & default_actions
+      elsif rest =~ /except:\s*\[([^\]]*)\]/
+        default_actions - $1.split(",").map { |s| s.strip.gsub(/[":\[\]']/, "").to_sym }
+      else
+        default_actions.dup
+      end
+    end
+
+    def register_controller_routes(controller, actions, param: nil)
+      @routes[controller] ||= { actions: [], param: nil }
+      @routes[controller][:actions] = (@routes[controller][:actions] + actions).uniq
+      @routes[controller][:param] = param if param
+    end
+
+    def routable_actions_for(controller_name)
+      if @routes.key?(controller_name)
+        @routes[controller_name][:actions]
+      else
+        RESTFUL_ACTIONS
+      end
+    end
+
+    def route_param_for(controller_name)
+      @routes.dig(controller_name, :param)
+    end
+
+    def parse_schema
+      schema_file = File.join(@codebase_path, "db", "schema.rb")
+      return {} unless File.exist?(schema_file)
+
+      content = File.read(schema_file)
+      tables = {}
+      current_table = nil
+      current_columns = {}
+
+      content.each_line do |line|
+        if line =~ /create_table\s+"(\w+)".*\bdo\b/
+          current_table = $1
+          current_columns = {}
+        elsif current_table && line =~ /t\.(\w+)\s+"(\w+)"/
+          current_columns[$2] = { type: $1.to_sym }
+        elsif current_table && line =~ /^\s*end\s*$/
+          tables[current_table] = current_columns
+          current_table = nil
+          current_columns = {}
+        end
+      end
+
+      tables
+    end
+
+    def table_name_for_model(model_name)
+      model_name.underscore.tr("/", "_").pluralize
+    end
+
+    def detect_missing_tests
+      schema_tables = parse_schema
+      models = @ast_nodes.select { |n| n[:type] == :model }
+      controllers = @ast_nodes.select { |n| n[:type] == :controller }
+
+      models.each do |model_node|
+        next if model_node[:model] == "ApplicationRecord"
+        expected_spec = "#{File.basename(model_node[:file], '.rb')}_spec.rb"
+        has_test = @existing_tests.any? { |t| t[:filename] == expected_spec }
+
+        unless has_test
+          suggestions = []
+          model_name = model_node[:model]
+          table_name = table_name_for_model(model_name)
+          model_columns = schema_tables.fetch(table_name, {})
+
+          if model_node.dig(:metadata, :validations)&.any?
+            suggestions << {
+              name: "Test active validations",
+              type: :validations,
+              model: model_name,
+              columns: model_columns,
+              fields: model_node[:metadata][:validations],
+              validations: model_node[:metadata][:validations]
+            }
+          end
+
+          if model_node.dig(:metadata, :associations)&.any?
+            assoc_types = model_node[:metadata][:associations].map { |a| a[:type] }.uniq
+            assoc_types.each do |assoc_type|
+              suggestions << {
+                name: "Test #{assoc_type} associations",
+                type: assoc_type,
+                model: model_name,
+                columns: model_columns,
+                associations: model_node[:metadata][:associations]
+              }
+            end
+          end
+
+          if model_node.dig(:metadata, :scopes)&.any?
+            suggestions << {
+              name: "Test model scopes",
+              type: :scopes,
+              model: model_name,
+              columns: model_columns,
+              scopes: model_node[:metadata][:scopes]
+            }
+          end
+
+          cb = model_node.dig(:metadata, :callbacks) || []
+          cb.each do |callback_name|
+            suggestions << {
+              name: "Test #{callback_name} callback",
+              type: callback_name,
+              model: model_name,
+              columns: model_columns,
+              callbacks: cb.map { |c| { type: c } }
+            }
+          end
+
+          if model_node.dig(:metadata, :custom_methods)&.any?
+            suggestions << {
+              name: "Test custom methods",
+              type: :custom_methods,
+              model: model_name,
+              columns: model_columns,
+              custom_methods: model_node[:metadata][:custom_methods]
+            }
+          end
+
+          if model_node.dig(:metadata, :delegation)&.any?
+            suggestions << {
+              name: "Test delegation",
+              type: :delegation,
+              model: model_name,
+              columns: model_columns
+            }
+          end
+
+          suggestions << {
+            name: "Test factory",
+            type: :factories,
+            model: model_name,
+            columns: model_columns,
+            associations: model_node.dig(:metadata, :associations)
+          }
+
+          @missing_tests << {
+            type: :unit,
+            model: model_name,
+            file: model_node[:file],
+            suggestions: suggestions
+          }
+        end
+      end
+
+      controllers.each do |controller_node|
+        controller_name = controller_node[:controller]
+        next if controller_name == "ApplicationController"
+
+        expected_spec = "#{File.basename(controller_node[:file], '.rb')}_spec.rb"
+        has_test = @existing_tests.any? { |t| t[:filename] == expected_spec }
+
+        unless has_test
+          routable = routable_actions_for(controller_name)
+          next if @routes_parsed && routable.empty?
+
+          inferred_model = controller_name.sub(/Controller$/, "").singularize
+          inferred_table = table_name_for_model(inferred_model)
+          inferred_columns = schema_tables.fetch(inferred_table, {})
+          route_param = route_param_for(controller_name)
+
+          suggestions = []
+          routable.each do |action|
+            next unless ACTION_ROUTE_MAP.key?(action)
+
+            ACTION_ROUTE_MAP[action].each do |type|
+              suggestions << {
+                name: "Test #{type} for #{controller_name}",
+                type: type,
+                controller: controller_name,
+                model: inferred_model,
+                columns: inferred_columns,
+                route_param: route_param
+              }
+            end
+          end
+
+          if !@routes_parsed || routable.include?(:create)
+            suggestions << {
+              name: "Test strong parameters permit for #{controller_name}",
+              type: :strong_parameters_permit,
+              controller: controller_name,
+              model: inferred_model,
+              columns: inferred_columns,
+              route_param: route_param
+            }
+            suggestions << {
+              name: "Test strong parameters deny for #{controller_name}",
+              type: :strong_parameters_deny,
+              controller: controller_name,
+              model: inferred_model,
+              columns: inferred_columns,
+              route_param: route_param
+            }
+          end
+
+          @missing_tests << {
+            type: :request,
+            controller: controller_name,
+            file: controller_node[:file],
+            suggestions: suggestions
+          }
+        end
+      end
+
+      stimulus_nodes = @ast_nodes.select { |n| n[:type] == :stimulus }
+      stimulus_nodes.each do |node|
+        controller_identifier = node[:controller]
+        next unless controller_identifier
+        next if controller_identifier == "application" || controller_identifier == "index"
+
+        expected_spec = "#{controller_identifier}_stimulus_spec.rb"
+        next if @existing_tests.any? { |t| t[:filename] == expected_spec }
+
+        @missing_tests << {
+          type: :stimulus,
+          controller: controller_identifier,
+          file: node[:file],
+          suggestions: [{
+            name: "Test #{controller_identifier} Stimulus controller",
+            type: :stimulus,
+            controller: controller_identifier,
+            targets: node[:targets] || [],
+            values: node[:values] || {},
+            classes: node[:classes] || [],
+            actions: node[:actions] || []
+          }]
+        }
+      end
+
+      cable_nodes = @ast_nodes.select { |n| n[:type] == :cable_subscription || n[:type] == :cable_broadcast }
+      channels = []
+      cable_nodes.each do |node|
+        if node[:type] == :cable_subscription
+          node[:subscriptions]&.each { |s| channels << s[:channel] }
+        elsif node[:type] == :cable_broadcast
+          (node[:channels] || []).each { |ch| channels << ch }
+        end
+      end
+      channels.uniq.each do |channel_name|
+        expected_spec = "#{channel_name.underscore}_cable_spec.rb"
+        next if @existing_tests.any? { |t| t[:filename] == expected_spec }
+
+        @missing_tests << {
+          type: :cable,
+          channel: channel_name,
+          file: nil,
+          suggestions: [{
+            name: "Test #{channel_name} channel",
+            type: :cable,
+            channel: channel_name
+          }]
+        }
+      end
+    end
+  end
+end