rbs 0.3.1 → 0.8.0

data/lib/rbs/test/test_helper.rb

@@ -1,183 +0,0 @@
-module RBS
-  module Test
-    module TypeAssertions
-      module ClassMethods
-        attr_reader :target
-
-        def library(*libs)
-          @libs = libs
-          @env = nil
-          @target = nil
-        end
-
-        def env
-          @env ||= begin
-                     loader = RBS::EnvironmentLoader.new
-                     (@libs || []).each do |lib|
-                       loader.add library: lib
-                     end
-
-                     RBS::Environment.new.tap do |env|
-                       loader.load(env: env)
-                     end
-                   end
-        end
-
-        def builder
-          @builder ||= DefinitionBuilder.new(env: env)
-        end
-
-        def testing(type_or_string)
-          type = case type_or_string
-                 when String
-                   RBS::Parser.parse_type(type_or_string, variables: [])
-                 else
-                   type_or_string
-                 end
-
-          definition = case type
-                       when Types::ClassInstance
-                         builder.build_instance(type.name)
-                       when Types::ClassSingleton
-                         builder.build_singleton(type.name)
-                       else
-                         raise "Test target should be class instance or class singleton: #{type}"
-                       end
-
-          @target = [type, definition]
-        end
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      def env
-        self.class.env
-      end
-
-      def builder
-        self.class.builder
-      end
-
-      def targets
-        @targets ||= []
-      end
-
-      def target
-        targets.last || self.class.target
-      end
-
-      def testing(type_or_string)
-        type = case type_or_string
-               when String
-                 RBS::Parser.parse_type(type_or_string, variables: [])
-               else
-                 type_or_string
-               end
-
-        definition = case type
-                     when Types::ClassInstance
-                       builder.build_instance(type.name)
-                     when Types::ClassSingleton
-                       builder.build_singleton(type.name)
-                     else
-                       raise "Test target should be class instance or class singleton: #{type}"
-                     end
-
-        targets.push [type, definition]
-
-        if block_given?
-          begin
-            yield
-          ensure
-            targets.pop
-          end
-        else
-          [type, definition]
-        end
-      end
-
-      ruby2_keywords def assert_send_type(method_type, receiver, method, *args, &block)
-        trace = []
-        spy = Spy.wrap(receiver, method)
-        spy.callback = -> (result) { trace << result }
-
-        exception = nil
-
-        begin
-          spy.wrapped_object.__send__(method, *args, &block)
-        rescue => exn
-          exception = exn
-        end
-
-        mt = case method_type
-             when String
-               RBS::Parser.parse_method_type(method_type, variables: [])
-             when RBS::MethodType
-               method_type
-             end
-
-        typecheck = TypeCheck.new(self_class: receiver.class, builder: builder)
-        errors = typecheck.method_call(method, mt, trace.last, errors: [])
-
-        assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.last.inspect}"
-
-        type, definition = target
-        method_types = case
-                       when definition.instance_type?
-                         subst = Substitution.build(definition.declaration.type_params.each.map(&:name),
-                                                    type.args)
-                         definition.methods[method].method_types.map do |method_type|
-                           method_type.sub(subst)
-                         end
-                       when definition.class_type?
-                         definition.methods[method].method_types
-                       end
-
-        all_errors = method_types.map {|t| typecheck.method_call(method, t, trace.last, errors: []) }
-        assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.last.inspect}\n  #{method_types.join(" | ")}"
-
-        if exception
-          raise exception
-        end
-      end
-
-      ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
-        trace = []
-        spy = Spy.wrap(receiver, method)
-        spy.callback = -> (result) { trace << result }
-
-        exception = nil
-        begin
-          spy.wrapped_object.__send__(method, *args, &block)
-        rescue Exception => exn
-          exception = exn
-        end
-
-        mt = case method_type
-             when String
-               RBS::Parser.parse_method_type(method_type, variables: [])
-             when RBS::MethodType
-               method_type
-             end
-
-        mt = mt.update(block: if mt.block
-                                MethodType::Block.new(
-                                  type: mt.block.type.with_return_type(Types::Bases::Any.new(location: nil)),
-                                  required: mt.block.required
-                                )
-                              end,
-                       type: mt.type.with_return_type(Types::Bases::Any.new(location: nil)))
-
-        typecheck = TypeCheck.new(self_class: receiver.class, builder: builder)
-        errors = typecheck.method_call(method, mt, trace.last, errors: [])
-
-        assert_operator exception, :is_a?, ::Exception
-        assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
-
-        exception
-      end
-    end
-  end
-end