rom 0.2.0 → 0.3.0

data/spec/integration/join_and_group_spec.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Joining and grouping relations' do
-  let(:env) do
-    Environment.setup(test: 'memory://test') do
-      schema do
-        base_relation :users do
-          repository :test
-
-          attribute :user_id, Integer
-          attribute :name, String
-
-          key :user_id
-        end
-
-        base_relation :tasks do
-          repository :test
-
-          attribute :id, Integer
-          attribute :user_id, Integer
-          attribute :title, String
-
-          key :id
-        end
-      end
-
-      mapping do
-        relation(:users) do
-          model User
-          map :user_id, :name
-        end
-
-        relation(:tasks) do
-          model Task
-          map :id, :user_id, :title
-        end
-      end
-    end
-  end
-
-  before do
-    User = mock_model(:user_id, :name, :tasks)
-    Task = mock_model(:id, :user_id, :title)
-
-    env.schema[:users].insert([[1, 'Jane']])
-    env.schema[:tasks].insert([[2, 1, 'Task 1'], [3, 1, 'Task 2']])
-  end
-
-  after do
-    Object.send(:remove_const, :User) if defined?(User)
-    Object.send(:remove_const, :Task) if defined?(Task)
-  end
-
-  specify 'loading a user with grouped tasks' do
-    users = env[:users]
-    tasks = env[:tasks]
-
-    loaded_user = users.join(tasks).group(:tasks => tasks).project([:user_id, :name, :tasks]).one
-
-    tuple = {
-      :name => 'Jane',
-      :tasks => [
-        { :id => 2, :user_id => 1, :title => 'Task 1' },
-        { :id => 3, :user_id => 1, :title => 'Task 2' }
-      ]
-    }
-
-    task1 = Task.new(tuple[:tasks].first)
-    task2 = Task.new(tuple[:tasks].last)
-    user = User.new(:name => tuple[:name], :tasks => [task1, task2])
-
-    expect(loaded_user).to eql(user)
-  end
-end

data/spec/integration/join_and_wrap_spec.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Joining and wrapping relations' do
-  let(:env) {
-    Environment.setup(test: 'memory://test') do
-      schema do
-        base_relation :users do
-          repository :test
-
-          attribute :user_id, Integer
-          attribute :name, String
-
-          key :id
-        end
-
-        base_relation :tasks do
-          repository :test
-
-          attribute :id, Integer
-          attribute :user_id, Integer
-          attribute :title, String
-
-          key :id
-        end
-      end
-
-      mapping do
-        relation(:users) do
-          model User
-          map :user_id, :name
-        end
-
-        relation(:tasks) do
-          model Task
-          map :id, :user_id, :title
-        end
-      end
-    end
-  }
-
-  before do
-    User = mock_model(:user_id, :name)
-    Task = mock_model(:id, :user_id, :title, :user)
-
-    env.schema[:users].insert([[2, 'Jane']])
-    env.schema[:tasks].insert([[1, 2, 'Task 1']])
-  end
-
-  after do
-    Object.send(:remove_const, :User) if defined?(User)
-    Object.send(:remove_const, :Task) if defined?(Task)
-  end
-
-  subject(:mapper) { env[:tasks].mapper.wrap(:user => env[:users].mapper) }
-
-  specify 'loading a task with wrapped user' do
-    loaded_task = env[:tasks].join(env[:users]).wrap(:user => env[:users]).project([:id, :title, :user]).one
-
-    tuple = { :id => 1, :user_id => 2, :title => 'Task 1', :user => { :user_id => 2, :name => 'Jane' } }
-
-    user = User.new(tuple[:user])
-    task = Task.new(:id => tuple[:id], :title => tuple[:title], :user => user)
-
-    expect(loaded_task).to eql(task)
-  end
-end

data/spec/integration/mapping_embedded_relations_spec.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Defining relation mappings' do
-  let!(:schema) {
-    env.schema {
-      base_relation :users do
-        repository :test
-
-        attribute :id,   Integer
-        attribute :name, String
-
-        key :id
-      end
-
-      base_relation :tasks do
-        repository :test
-
-        attribute :id, Integer
-        attribute :title, String
-
-        wrap user: users.header
-
-        key :id
-      end
-    }
-  }
-
-  let!(:env) {
-    Environment.setup(test: 'memory://test')
-  }
-
-  before do
-    User = mock_model(:id, :name)
-    Task = mock_model(:id, :title)
-  end
-
-  after do
-    Object.send(:remove_const, :User)
-    Object.send(:remove_const, :Task)
-  end
-
-  specify 'building registry of automatically mapped relations' do
-    pending "IMPLEMENT ME"
-
-    env.mapping do
-      users do
-        model User
-
-        map :id
-        map :name
-      end
-
-      tasks do
-        model Task
-
-        map :id
-        map :name
-        map :user, model: User
-      end
-    end
-
-    tasks = env[:tasks]
-
-    user = User.new(id: 1, name: 'Jane')
-    task = Task.new(id: 1, title: 'Test', user: user)
-
-    tasks.insert(task)
-
-    expect(tasks.to_a).to eql([task])
-  end
-end

data/spec/integration/mapping_relations_spec.rb

@@ -1,120 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Defining relation mappings' do
-  let!(:schema) {
-    env.schema {
-      base_relation :users do
-        repository :test
-
-        attribute :id, Integer
-        attribute :user_name, String, rename: :name
-        attribute :user_age, Integer
-
-        key :id
-      end
-    }
-  }
-
-  let!(:env) {
-    Environment.setup(test: 'memory://test')
-  }
-
-  specify 'building registry of automatically mapped relations' do
-    UserWithReaders = Class.new { attr_reader :id, :name, :age; include Equalizer.new(:id, :name, :age) }
-
-    env.mapping do
-      relation(:users) do
-        model UserWithReaders
-        map :id, :name
-        map :age, from: :user_age
-      end
-    end
-
-    users = env.finalize[:users]
-
-    jane = UserWithReaders.new
-    jane.instance_variable_set("@id", 1)
-    jane.instance_variable_set("@name", "Jane")
-    jane.instance_variable_set("@age", 30)
-
-    users.insert(jane)
-
-    expect(users.to_a).to eql([jane])
-  end
-
-  specify 'setting :attribute_hash loader strategy' do
-    AnimaUser = Class.new { include Anima.new(:id, :name, :age) }
-
-    env.mapping do
-      relation(:users) do
-        model AnimaUser
-        loader :attribute_hash
-        map :id, :name
-        map :age, from: :user_age
-      end
-    end
-
-    users = env.finalize[:users]
-
-    jane = AnimaUser.new(id: 1, name: 'Jane', age: 30)
-
-    users.insert(jane)
-
-    expect(users.to_a).to eql([jane])
-  end
-
-  specify 'setting :attribute_writers loader strategy' do
-    UserWithAccessors = Class.new {
-      include Equalizer.new(:id, :name, :age)
-      attr_accessor :name, :age
-      attr_reader :id_set, :id
-
-      def id=(id)
-        @id_set = true
-        @id = id
-      end
-    }
-
-    env.mapping do
-      relation(:users) do
-        model UserWithAccessors
-        loader :attribute_accessors
-        map :id, :name
-        map :age, from: :user_age
-      end
-    end
-
-    users = env.finalize[:users]
-
-    jane = UserWithAccessors.new
-    jane.id = 1
-    jane.name = 'Jane'
-    jane.age = 30
-
-    users.insert(jane)
-
-    expect(users.to_a).to eql([jane])
-    expect(jane.id_set).to be(true)
-  end
-
-  specify 'providing custom mapper' do
-    custom_model  = mock_model(:id, :name, :user_age)
-    custom_mapper = TestMapper.new(schema[:users].header, custom_model)
-
-    env.mapping do
-      relation(:users) do
-        mapper(custom_mapper)
-      end
-    end
-
-    users = env.finalize[:users]
-
-    jane = custom_model.new(id: 1, name: 'Jane', user_age: 30)
-
-    users.insert(jane)
-
-    expect(users.to_a).to eql([jane])
-  end
-end

data/spec/integration/schema_definition_spec.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'Defining a ROM schema' do
-  let(:people) {
-    Axiom::Relation::Base.new(:people, people_header)
-  }
-
-  let(:people_with_address) {
-    Axiom::Relation::Base.new(:people, people_header).wrap(
-      address: addresses.header
-    )
-  }
-
-  let(:people_with_profiles) {
-    Axiom::Relation::Base.new(:people, people_header).group(
-      profiles: profiles.header
-    )
-  }
-
-  let(:addresses) {
-    Axiom::Relation::Base.new(
-      :addresses,
-      [[:id, Integer], [:street, String], [:city, String], [:zipcode, String]]
-    )
-  }
-
-  let(:people_header) {
-    Axiom::Relation::Header.coerce(people_attributes, keys: people_keys)
-  }
-
-  let(:people_attributes) {
-    [[:id, Integer], [:name, String]]
-  }
-
-  let(:people_keys) {
-    [:id]
-  }
-
-  let(:profiles) {
-    Axiom::Relation::Base.new(:profiles, profiles_header)
-  }
-
-  let(:profiles_header) {
-    Axiom::Relation::Header.coerce(profiles_attributes, keys: profiles_keys)
-  }
-
-  let(:profiles_attributes) {
-    [[:id, Integer], [:person_id, Integer], [:text, String]]
-  }
-
-  let(:profiles_keys) {
-    [:id, :person_id]
-  }
-
-  let(:people_with_joined_profiles) {
-    people.join(profiles.rename(id: :profile_id, person_id: :id))
-  }
-
-  let(:env)        { Environment.setup(test: 'memory://test') }
-  let(:repository) { env.repository(:test) }
-
-  let(:schema) do
-    env.schema do
-      base_relation :addresses do
-        repository :test
-
-        attribute :id, Integer
-        attribute :street, String
-        attribute :city, String
-        attribute :zipcode, String
-      end
-
-      base_relation :people do
-        repository :test
-
-        attribute :id,   Integer
-        attribute :name, String
-
-        key :id
-      end
-
-      base_relation :profiles do
-        repository :test
-
-        attribute :id,        Integer
-        attribute :person_id, Integer
-        attribute :text,      String
-
-        key :id
-        key :person_id
-      end
-
-      base_relation :people_with_address do
-        repository :test
-
-        attribute :id,   Integer
-        attribute :name, String
-
-        wrap address: addresses.header
-
-        key :id
-      end
-
-      base_relation :people_with_profiles do
-        repository :test
-
-        attribute :id,   Integer
-        attribute :name, String
-
-        group profiles: profiles.header
-
-        key :id
-      end
-    end
-
-    env.schema do
-      relation :people_with_joined_profiles do
-        people.join(profiles.rename(id: :profile_id, person_id: :id))
-      end
-    end
-  end
-
-  it 'registers the people relation' do
-    expect(schema[:people]).to eq(people)
-  end
-
-  it 'registers the people with wrapped addresses relation' do
-    expect(schema[:people_with_address]).to eq(people_with_address)
-  end
-
-  it 'registers the people with grouped profiles relation' do
-    expect(schema[:people_with_profiles]).to eq(people_with_profiles)
-  end
-
-  it 'establishes key attributes for people relation' do
-    expect(schema[:people].header.keys).to include(*people_keys)
-  end
-
-  it 'establishes key attributes for profiles relation' do
-    expect(schema[:profiles].header.keys).to include(*profiles_keys)
-  end
-
-  it 'registers the profiles relation' do
-    expect(schema[:profiles]).to eq(profiles)
-  end
-
-  it 'registers the people_with_joined_profile relation' do
-    expect(schema[:people_with_joined_profiles]).to eq(people_with_joined_profiles)
-  end
-end