rom-http 0.7.0 → 0.8.0

data/spec/unit/rom/http/gateway_spec.rb

@@ -1,69 +0,0 @@
-require 'rom/lint/spec'
-
-RSpec.describe ROM::HTTP::Gateway do
-  include_context 'users and tasks'
-
-  it_behaves_like 'a rom gateway' do
-    let(:identifier) { :http }
-    let(:gateway) { ROM::HTTP::Gateway }
-    let(:options) do
-      {
-        uri: 'http://localhost:3000',
-        request_handler: request_handler,
-        response_handler: response_handler
-      }
-    end
-    # H4xz0rz
-    let(:uri) { options }
-  end
-
-  describe '#dataset?' do
-    it 'returns true if a table exists' do
-      expect(gateway.dataset?(:users)).to be(true)
-    end
-
-    it 'returns false if a table does not exist' do
-      expect(gateway.dataset?(:not_here)).to be(false)
-    end
-  end
-
-  describe '#dataset' do
-    subject { gateway.dataset(:name) }
-
-    context 'when extended' do
-      let(:gateway) { Test::Gateway.new({}) }
-
-      before do
-        module Test
-          class Gateway < ROM::HTTP::Gateway; end
-        end
-      end
-
-      context 'when no Dataset defined in the same namespace' do
-        it 'returns ROM::HTTP::Dataset' do
-          is_expected.to be_kind_of(ROM::HTTP::Dataset)
-        end
-      end
-
-      context 'when Dataset defined in the same namespace' do
-        before do
-          module Test
-            class Dataset < ROM::HTTP::Dataset; end
-          end
-        end
-
-        it 'returns ROM::HTTP::Dataset' do
-          is_expected.to be_kind_of(Test::Dataset)
-        end
-      end
-    end
-
-    context 'when not extended' do
-      let(:gateway) { ROM::HTTP::Gateway.new({}) }
-
-      it 'returns ROM::HTTP::Dataset' do
-        is_expected.to be_kind_of(ROM::HTTP::Dataset)
-      end
-    end
-  end
-end

data/spec/unit/rom/http/relation_spec.rb

@@ -1,268 +0,0 @@
-RSpec.describe ROM::HTTP::Relation do
-  let(:relation_klass) do
-    Class.new(ROM::HTTP::Relation) do
-      schema do
-        attribute :id, ROM::Types::Strict::Int
-        attribute :name, ROM::Types::Strict::String
-      end
-    end
-  end
-  let(:relation) { relation_klass.new(dataset) }
-  let(:dataset) { ROM::HTTP::Dataset.new({ name: 'test' }, {}) }
-  let(:data) do
-    [
-      {
-        id: 1,
-        name: 'John'
-      },
-      {
-        id: 2,
-        name: 'Jill'
-      }
-    ]
-  end
-
-  before do
-    allow(dataset).to receive(:response).and_return(data)
-  end
-
-  describe '#primary_key' do
-    subject { relation.primary_key }
-
-    context 'with no primary key defined in schema' do
-      it 'defaults to :id' do
-        is_expected.to eq(:id)
-      end
-    end
-
-    context 'with primary key defined in schema' do
-      context 'without alias' do
-        let(:relation_klass) do
-          Class.new(ROM::HTTP::Relation) do
-            schema do
-              attribute :id, ROM::Types::Strict::Int
-              attribute :name, ROM::Types::Strict::String.meta(primary_key: true)
-            end
-          end
-        end
-
-        it 'returns the attribute name of the primary key' do
-          is_expected.to eq(:name)
-        end
-      end
-
-      context 'with alias' do
-        let(:relation_klass) do
-          Class.new(ROM::HTTP::Relation) do
-            schema do
-              attribute :id, ROM::Types::Strict::Int.meta(primary_key: true, alias: :ident)
-              attribute :name, ROM::Types::Strict::String
-            end
-          end
-        end
-
-        it 'returns the attribute name of the primary key' do
-          is_expected.to eq(:ident)
-        end
-      end
-    end
-  end
-
-  describe '#project' do
-    subject { relation.project(:id).to_a }
-
-    it 'returns the projected data' do
-      is_expected.to match_array([
-        { id: 1 },
-        { id: 2 }
-      ])
-    end
-  end
-
-  describe '#exclude' do
-    subject { relation.exclude(:id).to_a }
-
-    it 'returns the data with specified keys excluded' do
-      is_expected.to match_array([
-        { name: 'John' },
-        { name: 'Jill' }
-      ])
-    end
-  end
-
-  describe '#rename' do
-    subject { relation.rename(id: :identity).to_a }
-
-    it 'returns the data with keys renamed according to mapping' do
-      is_expected.to match_array([
-        { name: 'John', identity: 1 },
-        { name: 'Jill', identity: 2 }
-      ])
-    end
-  end
-
-  describe '#prefix' do
-    subject { relation.prefix('user').to_a }
-
-    it 'returns the data with prefixed keys' do
-      is_expected.to match_array([
-        { user_id: 1, user_name: 'John' },
-        { user_id: 2, user_name: 'Jill' }
-      ])
-    end
-  end
-
-  describe '#wrap' do
-    context 'when called without a prefix' do
-      subject { relation.wrap.to_a }
-
-      it 'returns the data with keys prefixed by dataset name' do
-        is_expected.to match_array([
-          { test_id: 1, test_name: 'John' },
-          { test_id: 2, test_name: 'Jill' }
-        ])
-      end
-    end
-
-    context 'when called with a prefix' do
-      subject { relation.wrap('user').to_a }
-
-      it 'returns the data with keys prefixed by the given prefix' do
-        is_expected.to match_array([
-          { user_id: 1, user_name: 'John' },
-          { user_id: 2, user_name: 'Jill' }
-        ])
-      end
-    end
-  end
-
-  describe '#to_a' do
-    subject { relation.to_a }
-
-    context 'with standard schema' do
-      let(:relation_klass) do
-        Class.new(ROM::HTTP::Relation) do
-          schema do
-            attribute :id, ROM::Types::Strict::Int
-          end
-        end
-      end
-
-      it 'applies the schema and returns the materialized results' do
-        is_expected.to match_array([
-          { id: 1 },
-          { id: 2 }
-        ])
-      end
-    end
-
-    context 'with aliased schema' do
-      let(:relation_klass) do
-        Class.new(ROM::HTTP::Relation) do
-          schema do
-            attribute :id, ROM::Types::Strict::Int
-            attribute :name, ROM::Types::Strict::String.meta(alias: :username)
-          end
-        end
-      end
-
-      it 'applies the schema and returns the materialized results' do
-        is_expected.to match_array([
-          { id: 1, username: 'John' },
-          { id: 2, username: 'Jill' }
-        ])
-      end
-    end
-  end
-
-  %i[insert update].each do |method_name|
-    describe "##{method_name}" do
-      subject { relation.send(method_name, name: 'John') }
-
-      before do
-        allow(dataset).to receive(method_name).and_return(data)
-      end
-
-      context 'with standard schema' do
-        let(:relation_klass) do
-          Class.new(ROM::HTTP::Relation) do
-            schema do
-              attribute :id, ROM::Types::Strict::Int
-            end
-          end
-        end
-
-        context 'when respond with single tuple' do
-          let(:data) { { id: 1, name: 'John' } }
-
-          it 'applies the schema and returns the materialized results' do
-            is_expected.to eq(id: 1)
-          end
-        end
-
-        context 'when respond with multiple tuples' do
-          let(:data) do
-            [
-              {
-                id: 1,
-                name: 'John'
-              },
-              {
-                id: 2,
-                name: 'Jill'
-              }
-            ]
-          end
-
-          it 'applies the schema and returns the materialized results' do
-            is_expected.to match_array([
-              { id: 1 },
-              { id: 2 }
-            ])
-          end
-        end
-      end
-
-      context 'with aliased schema' do
-        let(:relation_klass) do
-          Class.new(ROM::HTTP::Relation) do
-            schema do
-              attribute :id, ROM::Types::Strict::Int
-              attribute :name, ROM::Types::Strict::String.meta(alias: :username)
-            end
-          end
-        end
-
-        context 'when respond with single tuple' do
-          let(:data) { { id: 1, name: 'John' } }
-
-          it 'applies the schema and returns the materialized results' do
-            is_expected.to eq(id: 1, username: 'John')
-          end
-        end
-
-        context 'when respond with multiple tuples' do
-          let(:data) do
-            [
-              {
-                id: 1,
-                name: 'John'
-              },
-              {
-                id: 2,
-                name: 'Jill'
-              }
-            ]
-          end
-
-          it 'applies the schema and returns the materialized results' do
-            is_expected.to match_array([
-              { id: 1, username: 'John' },
-              { id: 2, username: 'Jill' }
-            ])
-          end
-        end
-      end
-    end
-  end
-end