wsdl-mapper 0.0.7

data/test/wsdl_mapper/runtime/middleware_stack_test.rb

@@ -0,0 +1,130 @@
+require 'test_helper'
+
+require 'wsdl_mapper/runtime/middleware_stack'
+
+module RuntimeTests
+  class MiddlewareStackTest < WsdlMapperTesting::Test
+    include WsdlMapper::Runtime
+
+    def test_add
+      stack = MiddlewareStack.new
+
+      stack.add 'some.middleware', Object.new
+
+      assert_equal 1, stack.count
+    end
+
+    def test_names
+      stack = MiddlewareStack.new
+
+      stack.add 'some.middleware', Object.new
+      stack.add 'some.other.middleware', Object.new
+
+      assert_equal ['some.middleware', 'some.other.middleware'], stack.names
+    end
+
+    def test_replace
+      stack = MiddlewareStack.new
+      middleware_old = Object.new
+      stack.add 'some.middleware', middleware_old
+
+      middleware_new = Object.new
+      stack.replace 'some.middleware', middleware_new
+
+      assert_equal [middleware_new], stack.to_a
+    end
+
+    def test_clear
+      stack = MiddlewareStack.new
+      stack.add 'some.middleware', Object.new
+
+      stack.clear
+
+      assert_equal 0, stack.count
+    end
+
+    def test_remove
+      stack = MiddlewareStack.new
+
+      stack.add 'some.middleware', Object.new
+      stack.add 'some.other.middleware', Object.new
+
+      stack.remove 'some.middleware'
+
+      assert_equal ['some.other.middleware'], stack.names
+    end
+
+    def test_get
+      stack = MiddlewareStack.new
+      middleware = Object.new
+      stack.add 'some.middleware', middleware
+
+      assert_equal middleware, stack.get('some.middleware')
+    end
+
+    def test_get_error
+      stack = MiddlewareStack.new
+      middleware = Object.new
+      stack.add 'some.middleware', middleware
+
+      begin
+        stack.get('some.other.middleware')
+        assert false
+      rescue => e
+        assert_kind_of ArgumentError, e
+        assert_equal 'some.other.middleware not found.', e.message
+      end
+    end
+
+    def test_prepend
+      stack = MiddlewareStack.new
+
+      stack.add 'some.other.middleware', Object.new
+      stack.prepend 'some.middleware', Object.new
+
+      assert_equal ['some.middleware', 'some.other.middleware'], stack.names
+    end
+
+    def test_after
+      stack = MiddlewareStack.new
+
+      stack.add 'some.other.middleware', Object.new
+      stack.add 'some.more.middleware', Object.new
+      stack.after 'some.other.middleware', 'some.middleware', Object.new
+
+      assert_equal ['some.other.middleware', 'some.middleware', 'some.more.middleware'], stack.names
+    end
+
+    def test_before
+      stack = MiddlewareStack.new
+
+      stack.add 'some.other.middleware', Object.new
+      stack.add 'some.more.middleware', Object.new
+      stack.before 'some.more.middleware', 'some.middleware', Object.new
+
+      assert_equal ['some.other.middleware', 'some.middleware', 'some.more.middleware'], stack.names
+    end
+
+    def test_each
+      stack = MiddlewareStack.new
+      middleware1 = Object.new
+      stack.add 'some.middleware', middleware1
+      middleware2 = Object.new
+      stack.add 'some.middleware', middleware2
+
+      middlewares = stack.each.to_a
+
+      assert_equal middlewares, [middleware1, middleware2]
+    end
+
+    def test_execute
+      stack = MiddlewareStack.new
+      stack.add 'first', ->(input) { [input.upcase, 'ipsum'] }
+      stack.add 'second', -> (input1, input2) { (input1 + input2).reverse }
+
+      output = stack.execute 'lorem'
+
+      assert_equal 'muspiMEROL', output
+    end
+  end
+end

data/test/wsdl_mapper/runtime/middlewares/simple_dispatcher_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+require 'wsdl_mapper_testing/stub_connection'
+
+require 'wsdl_mapper/runtime/request'
+require 'wsdl_mapper/runtime/middlewares/simple_dispatcher'
+
+module RuntimeTests
+  module MiddlewareTests
+    class SimpleDispatcherTest < Minitest::Test
+      def setup
+        @cnx = WsdlMapperTesting::StubConnection.new
+        @dispatcher = WsdlMapper::Runtime::Middlewares::SimpleDispatcher.new @cnx
+      end
+
+      def fake_request(url, body)
+        request = WsdlMapper::Runtime::Request.new(nil)
+        request.xml = body
+        request.url = URI url
+        request
+      end
+
+      def test_successful_request
+        request = fake_request '/some-url', 'foo bar'
+        @cnx.stub_request '/some-url', 'foo bar', 'lorem ipsum'
+
+        _op, response = @dispatcher.call nil, request
+
+        assert_equal 200, response.status
+        assert_equal 'lorem ipsum', response.body
+      end
+
+      def test_error_on_request
+        request = fake_request '/some-url', 'foo bar'
+        @cnx.stub_error '/some-url', Faraday::Error.new('connection failed')
+
+        begin
+          @dispatcher.call nil, request
+          assert false
+        rescue => e
+          assert_kind_of WsdlMapper::Runtime::Errors::TransportError, e
+        end
+      end
+    end
+  end
+end

data/test/wsdl_mapper/runtime/operation_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+require 'wsdl_mapper/runtime/operation'
+
+module RuntimeTests
+  class OperationTest < WsdlMapperTesting::Test
+    class TestOperation < WsdlMapper::Runtime::Operation
+      attr_reader :requires, :loaded_requires, :loaded
+      attr_accessor :port, :soap_action
+
+      def initialize
+        super(nil, nil, nil)
+        @loaded_requires = []
+      end
+
+      def require(path)
+        @loaded_requires << path
+      end
+    end
+
+    def test_requiring
+      op = TestOperation.new
+      op.requires << 'some_module'
+
+      op.load_requires
+
+      assert op.loaded
+      assert_equal ['some_module'], op.loaded_requires
+    end
+
+    def test_requiring_twice
+      op = TestOperation.new
+      op.requires << 'some_module'
+
+      op.load_requires
+      op.load_requires
+
+      assert_equal ['some_module'], op.loaded_requires
+    end
+
+    def test_loading_on_use
+      methods = %w[new_input new_output input_s8r output_s8r input_d10r output_d10r]
+
+      methods.each do |method|
+        op = TestOperation.new
+        op.send method
+        assert op.loaded
+      end
+    end
+
+    def test_envelope_creation
+      op = TestOperation.new
+      header = Object.new
+      body = Object.new
+
+      envelope = op.new_envelope header, body
+
+      assert_kind_of WsdlMapper::SvcDesc::Envelope, envelope
+      assert_equal header, envelope.header
+      assert_equal body, envelope.body
+    end
+
+    def test_message_creation
+      op = TestOperation.new
+      op.soap_action = 'SomeAction'
+      op.port = Minitest::Mock.new.expect(:_soap_address, '/some-url')
+      header = Object.new
+      body = Object.new
+
+      message = op.new_message header, body
+
+      assert_kind_of WsdlMapper::Runtime::Message, message
+      assert_equal 'SomeAction', message.action
+      assert_equal '/some-url', message.address
+      assert_equal header, message.envelope.header
+      assert_equal body, message.envelope.body
+    end
+  end
+end

data/test/wsdl_mapper/runtime/simple_http_backend_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'wsdl_mapper_testing/fake_operation'
+
+require 'wsdl_mapper/runtime/simple_http_backend'
+
+module RuntimeTests
+  class SimpleHttpBackendTest < WsdlMapperTesting::Test
+    def setup
+      @operation = FakeOperation.new
+
+      @cnx = WsdlMapperTesting::StubConnection.new
+      @test_url = 'http://example.org/some-url'
+      @test_action = 'SomeAction'
+      @input = Object.new
+      @output = Object.new
+      @message = WsdlMapper::Runtime::Message.new @test_url, @test_action, @input
+      @backend = WsdlMapper::Runtime::SimpleHttpBackend.new(connection: @cnx)
+    end
+
+    def setup_mock_request_response(request_xml, response_xml)
+      @operation.input_s8r.xml_for_input @input, request_xml
+      @operation.output_d10r.output_for_xml response_xml, @output
+      @operation.input_for_body @input, @message
+    end
+
+    def test_a_successful_request
+      setup_mock_request_response 'foo bar', 'lorem ipsum'
+      @cnx.stub_request @test_url, 'foo bar', 'lorem ipsum'
+
+      response = @backend.dispatch @operation, @input
+
+      assert_kind_of WsdlMapper::Runtime::Response, response
+      assert_equal 'lorem ipsum', response.body
+      assert_equal @output, response.envelope
+    end
+
+    def test_a_transport_error
+      setup_mock_request_response 'foo bar', 'lorem ipsum'
+      @cnx.stub_error @test_url, Faraday::Error.new
+
+      begin
+        @backend.dispatch @operation, @input
+        assert false, 'Expected an error'
+      rescue => e
+        assert_kind_of WsdlMapper::Runtime::Errors::TransportError, e
+      end
+    end
+  end
+end

data/test/wsdl_mapper/s8r_generation/s8r_generator_test.rb

@@ -0,0 +1,450 @@
+require 'test_helper'
+
+require 'wsdl_mapper/dom_parsing/parser'
+require 'wsdl_mapper/generation/context'
+require 'wsdl_mapper/s8r_generation/s8r_generator'
+
+module S8rGenerationTests
+  class S8rGeneratorTests < GenerationTest
+    def generate(name)
+      schema = get_schema name
+      generator = WsdlMapper::S8rGeneration::S8rGenerator.new context
+      generator.generate schema
+    end
+
+    def test_basic_empty_type
+      generate 'empty_note_type.xsd'
+
+      assert_file_is 's8r_type_directory.rb', <<RUBY
+require "wsdl_mapper/serializers/type_directory"
+
+S8rTypeDirectory = ::WsdlMapper::Serializers::TypeDirectory.new do
+  register_type("::NoteType", "note_type_serializer", "::NoteTypeSerializer")
+  register_element("::NoteType", [nil, "note"])
+end
+RUBY
+
+      assert_file_is 'serializer.rb', <<RUBY
+require "wsdl_mapper/serializers/serializer_factory"
+require "s8r_type_directory"
+
+Serializer = ::WsdlMapper::Serializers::SerializerFactory.new(::S8rTypeDirectory)
+RUBY
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex([nil, "noteType"], name, attributes) do |x|
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_inline_complex_type
+      generate 'basic_note_type_with_inline_complex_type.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex([nil, "noteType"], name, attributes) do |x|
+      x.value_builtin([nil, "to"], obj.to, "string")
+      x.value_builtin([nil, "from"], obj.from, "string")
+      x.value_builtin([nil, "heading"], obj.heading, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+      x.get("::AttachmentInlineType").build(x, obj.attachment, [nil, "attachment"])
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+
+      assert_file_is 'attachment_inline_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class AttachmentInlineTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex(nil, name, attributes) do |x|
+      x.value_builtin([nil, "name"], obj.name, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::AttachmentInlineTypeSerializer", ::AttachmentInlineTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_attribute
+      generate 'basic_note_type_with_property_and_attribute.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = [
+      [[nil, "uuid"], obj.uuid, "token"]
+    ]
+    x.complex([nil, "noteType"], name, attributes) do |x|
+      x.value_builtin([nil, "to"], obj.to, "string")
+      x.value_builtin([nil, "from"], obj.from, "string")
+      x.value_builtin([nil, "heading"], obj.heading, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_simple_type
+      generate 'address_type_enumeration.xsd'
+
+      assert_file_is 'address_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class AddressTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    x.simple([nil, "addressType"], name) do |x|
+      x.text_builtin(obj, "token")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::AddressTypeSerializer", ::AddressTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_target_namespace
+      generate 'basic_note_type_with_target_namespace.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex(["http://example.org/schema", "noteType"], name, attributes) do |x|
+      x.value_builtin(["http://example.org/schema", "to"], obj.to, "string")
+      x.value_builtin(["http://example.org/schema", "from"], obj.from, "string")
+      x.value_builtin(["http://example.org/schema", "heading"], obj.heading, "string")
+      x.value_builtin(["http://example.org/schema", "body"], obj.body, "string")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_import
+      generate 'basic_note_type_with_import.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex(["http://example.org/notes", "noteType"], name, attributes) do |x|
+      x.value_builtin(["http://example.org/notes", "to"], obj.to, "string")
+      x.value_builtin(["http://example.org/notes", "from"], obj.from, "string")
+      x.value_builtin(["http://example.org/notes", "heading"], obj.heading, "string")
+      x.value_builtin(["http://example.org/notes", "body"], obj.body, "string")
+      obj.attachments.each do |itm|
+        x.get("::AttachmentType").build(x, itm, ["http://example.org/notes", "attachments"])
+      end
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_array
+      generate 'basic_note_type_with_attachments.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex([nil, "noteType"], name, attributes) do |x|
+      x.value_builtin([nil, "to"], obj.to, "string")
+      x.value_builtin([nil, "from"], obj.from, "string")
+      x.value_builtin([nil, "heading"], obj.heading, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+      obj.attachments.each do |itm|
+        x.value_builtin([nil, "attachments"], itm, "string")
+      end
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_array_simple_type
+      generate 'basic_note_type_with_attachments_simple_type.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex([nil, "noteType"], name, attributes) do |x|
+      x.value_builtin([nil, "to"], obj.to, "string")
+      x.value_builtin([nil, "from"], obj.from, "string")
+      x.value_builtin([nil, "heading"], obj.heading, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+      obj.attachments.each do |itm|
+        x.get("::AttachmentType").build(x, itm, [nil, "attachments"])
+      end
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_reference
+      generate 'basic_note_type_with_referenced_simple_email_address_type.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex([nil, "noteType"], name, attributes) do |x|
+      x.get("::EmailAddressType").build(x, obj.to, [nil, "to"])
+      x.get("::EmailAddressType").build(x, obj.from, [nil, "from"])
+      x.value_builtin([nil, "heading"], obj.heading, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+
+      assert_file_is 'email_address_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class EmailAddressTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    x.simple([nil, "emailAddressType"], name) do |x|
+      x.text_builtin(obj, "string")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::EmailAddressTypeSerializer", ::EmailAddressTypeSerializer.new)
+RUBY
+    end
+
+    def test_soap_array
+      generate 'basic_note_type_with_soap_array.xsd'
+
+      assert_file_is 'attachments_array_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class AttachmentsArraySerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = [
+      [[x.soap_enc, "arrayType"], [nil, "attachment[\#{obj.length}]"], "string"]
+    ]
+    x.complex([nil, "attachmentsArray"], name, attributes) do |x|
+      obj.each do |itm|
+        x.get("::Attachment").build(x, itm, [nil, "item"])
+      end
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::AttachmentsArraySerializer", ::AttachmentsArraySerializer.new)
+RUBY
+    end
+
+    def test_soap_array_simple
+      generate 'basic_note_type_with_soap_array_simple.xsd'
+
+      assert_file_is 'attachments_array_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class AttachmentsArraySerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = [
+      [[x.soap_enc, "arrayType"], [nil, "attachment[\#{obj.length}]"], "string"]
+    ]
+    x.complex([nil, "attachmentsArray"], name, attributes) do |x|
+      obj.each do |itm|
+        x.get("::Attachment").build(x, itm, [nil, "item"])
+      end
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::AttachmentsArraySerializer", ::AttachmentsArraySerializer.new)
+RUBY
+    end
+
+    def test_soap_array_builtin
+      generate 'basic_note_type_with_soap_array_builtin.xsd'
+
+      assert_file_is 'attachments_array_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class AttachmentsArraySerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = [
+      [[x.soap_enc, "arrayType"], ["http://www.w3.org/2001/XMLSchema", "string[\#{obj.length}]"], "string"]
+    ]
+    x.complex([nil, "attachmentsArray"], name, attributes) do |x|
+      obj.each do |itm|
+        x.value_builtin([nil, "item"], itm, "string")
+      end
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::AttachmentsArraySerializer", ::AttachmentsArraySerializer.new)
+RUBY
+    end
+
+    def test_complex_type_with_simple_content
+      generate 'simple_money_type_with_currency_attribute.xsd'
+
+      assert_file_is 'money_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class MoneyTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = [
+      [[nil, "currency"], obj.currency, "token"]
+    ]
+    x.complex([nil, "moneyType"], name, attributes) do |x|
+      x.text_builtin(obj.content, "float")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::MoneyTypeSerializer", ::MoneyTypeSerializer.new)
+RUBY
+    end
+
+    def test_basic_type_with_properties
+      generate 'basic_note_type.xsd'
+
+      assert_file_is 'note_type_serializer.rb', <<RUBY
+require "s8r_type_directory"
+
+class NoteTypeSerializer
+
+  def build(x, obj, name)
+    return if obj.nil?
+    attributes = []
+    x.complex([nil, "noteType"], name, attributes) do |x|
+      x.value_builtin([nil, "to"], obj.to, "string")
+      x.value_builtin([nil, "from"], obj.from, "string")
+      x.value_builtin([nil, "heading"], obj.heading, "string")
+      x.value_builtin([nil, "body"], obj.body, "string")
+    end
+  end
+end
+::S8rTypeDirectory.register_serializer("::NoteTypeSerializer", ::NoteTypeSerializer.new)
+RUBY
+    end
+
+    def test_simple_s8r_generation_with_modules
+      schema = TestHelper.parse_schema 'basic_note_type.xsd'
+      context = WsdlMapper::Generation::Context.new @tmp_path.to_s
+      generator = WsdlMapper::S8rGeneration::S8rGenerator.new context, namer: WsdlMapper::Naming::DefaultNamer.new(module_path: %w[NotesApi S8r])
+
+      result = generator.generate schema
+
+      expected_file = @tmp_path.join('notes_api', 's8r', 'note_type_serializer.rb')
+      assert File.exists? expected_file
+      assert_includes result.files, expected_file
+
+      generated_class = File.read expected_file
+      assert_equal <<RUBY, generated_class
+require "notes_api/s8r/s8r_type_directory"
+
+module NotesApi
+  module S8r
+    class NoteTypeSerializer
+
+      def build(x, obj, name)
+        return if obj.nil?
+        attributes = []
+        x.complex([nil, "noteType"], name, attributes) do |x|
+          x.value_builtin([nil, "to"], obj.to, "string")
+          x.value_builtin([nil, "from"], obj.from, "string")
+          x.value_builtin([nil, "heading"], obj.heading, "string")
+          x.value_builtin([nil, "body"], obj.body, "string")
+        end
+      end
+    end
+  end
+end
+::NotesApi::S8r::S8rTypeDirectory.register_serializer("::NotesApi::S8r::NoteTypeSerializer", ::NotesApi::S8r::NoteTypeSerializer.new)
+RUBY
+
+      root_node = result.module_tree.first
+      assert_equal 'NotesApi', root_node.type_name.module_name
+      middle_node = root_node.children.first
+      assert_equal 'S8r', middle_node.type_name.module_name
+      type_node = middle_node.children.first
+      assert_equal 'NoteTypeSerializer', type_node.type_name.class_name
+
+      expected_file = @tmp_path.join('notes_api', 's8r.rb')
+      assert File.exists? expected_file
+
+      generated_file = File.read expected_file
+      assert_equal <<RUBY, generated_file
+require "notes_api/s8r/note_type_serializer"
+RUBY
+
+      expected_file = @tmp_path.join('notes_api.rb')
+      assert File.exists? expected_file
+
+      generated_file = File.read expected_file
+      assert_equal <<RUBY, generated_file
+require "notes_api/s8r"
+RUBY
+    end
+  end
+end