synchronisable 0.0.2

data/spec/factories/remote/player.rb

@@ -0,0 +1,18 @@
+FactoryGirl.define do
+  factory :remote_player, class: Hash do
+    player_id { generate :player_id }
+    team { generate :team_id }
+
+    eman_tsrif  { generate :first_name }
+    eman_tsal   { generate :last_name }
+    yadhtrib    { generate :date }
+    pihsnezitic { generate :string }
+    thgieh      { generate :integer }
+    thgiew      { generate :integer }
+
+    ignored_1 { generate :string }
+    ignored_2 { generate :integer }
+
+    initialize_with { attributes }
+  end
+end

data/spec/factories/remote/stage.rb

@@ -0,0 +1,26 @@
+FactoryGirl.define do
+  factory :remote_stage, class: Hash do
+    stage_id  { generate :stage_id }
+    tour_id   { generate :tournament_id }
+
+    eman      { generate :string }
+    rebmun    { generate :integer }
+    gninnigeb { generate :timestamp }
+    gnidge    { generate :date }
+
+    ignored_1 { generate :date }
+    ignored_2 { generate :timestamp }
+
+    initialize_with { attributes }
+
+    trait :with_matches do
+      after(:build) do
+        match = build(:remote_match,
+          :home_team => 'team_0',
+          :away_team => 'team_1'
+        )
+        object[:matches_ids] = [match[:match_id]]
+      end
+    end
+  end
+end

data/spec/factories/remote/team.rb

@@ -0,0 +1,21 @@
+FactoryGirl.define do
+  factory :remote_team, class: Hash do
+    maet_id { generate :team_id }
+
+    eman    { generate :name }
+    yrtnuoc { generate :string }
+    ytic    { generate :string }
+
+    ignored_1 { generate :string }
+    ignored_2 { generate :timestamp }
+
+    initialize_with { attributes }
+
+    trait :with_players do
+      after(:build) do |object, evaluator|
+        players = build_list(:remote_player, 4, team: object[:maet_id])
+        object[:players_ids] = players.map { |h| h[:player_id] }
+      end
+    end
+  end
+end

data/spec/factories/remote/tournament.rb

@@ -0,0 +1,18 @@
+FactoryGirl.define do
+  factory :remote_tournament, class: Hash do
+    tour_id    { generate :tournament_id }
+    eman       { generate :string }
+    eman_trohs { generate :string }
+    gninnigeb  { generate :date }
+    gnidge     { generate :date }
+
+    initialize_with { attributes }
+
+    trait :with_stages do
+      after(:build) do |object, evaluator|
+        stages = build_list(:remote_stage, 2, tour_id: object[:tour_id])
+        object[:stages_ids] = stages.map { |h| h[:stage_id] }
+      end
+    end
+  end
+end

data/spec/factories/stadium.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :stadium do
+    name     { generate :string  }
+    capacity { generate :integer }
+  end
+end
+

data/spec/factories/team.rb

@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :team do
+    name { generate :string }
+
+    trait :with_stadium do
+      association :stadium
+    end
+
+    trait :with_players do
+      after(:build) do |object, evaluator|
+        create_list(:player, 11, :team => object)
+      end
+    end
+  end
+end
+

data/spec/models/match_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Match do
+  describe 'synchronization' do
+    context 'when has associations defined in Synchronizer' do
+      subject do
+        -> { Match.sync }
+      end
+
+      it { should change { Match.count }.by(1) }
+      it { should change { Team.count }.by(2) }
+      it { should change { Player.count }.by(4) }
+      it { should change { MatchPlayer.count }.by(4) }
+
+      it { should change { Synchronizable::Import.count }.by(11) }
+    end
+
+    # TODO: Left here until :include option is implemented
+    #
+    # context 'when associations specified with :include option' do
+    #   subject do
+    #     -> { sync_match }
+    #   end
+
+    #   def sync_match
+    #     Match.sync(:include => {
+    #       :match => {
+    #         :team => :players
+    #       }
+    #     })
+    #   end
+
+    #   it { should change { Match.count }.by(1) }
+    #   it { should change { Team.count }.by(2) }
+    #   it { should change { Player.count }.by(22) }
+    #   it { should change { MatchPlayer.count }.by(22) }
+
+    #   it { should change { Synchronizable::Import.count }.by(47) }
+    # end
+  end
+end

data/spec/models/team_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Team do
+  describe 'synchronization' do
+    let!(:remote_attrs) do
+      [
+        {
+          :maet_id   => 'team1',
+          :eman      => 'y',
+          :yrtnuoc   => 'USA',
+          :ytic      => 'Washington',
+          :ignored_1 => 'ignored',
+          :ignored_2 => 'ignored'
+        },
+        {
+          :maet_id   => 'team2',
+          :eman      => 'z',
+          :yrtnuoc   => 'France',
+          :ytic      => 'Paris',
+          :ignored_2 => 'ignored'
+        },
+        {
+          :eman      => 'a',
+          :yrtnuoc   => 'blah',
+          :ytic      => 'blah'
+        }
+      ]
+    end
+
+    context 'sync with no data specified' do
+      subject do
+        -> { Team.sync }
+      end
+
+      it { should change { Team.count }.by(2) }
+      it { should change { Player.count }.by(4) }
+
+      it { should change { Synchronizable::Import.count }.by(6) }
+    end
+
+    context 'when remote id is not specified' do
+      subject { Team.sync([remote_attrs.last]) }
+
+      its(:errors) { should have(1).items }
+    end
+
+    context 'when local record does not exist' do
+      subject do
+        -> { Team.sync(remote_attrs.take(2)) }
+      end
+
+      it { should change { Team.count }.by(2) }
+      it { should change { Synchronizable::Import.count }.by(2) }
+    end
+
+    context 'when local and import records exists' do
+      let!(:import) do
+        create(:import,
+          :remote_id => 'team1',
+          :synchronizable => create(:team,
+            :name => 'x',
+            :country => 'Russia',
+            :city => 'Moscow',
+          )
+        )
+      end
+
+      let!(:team) { import.synchronizable }
+
+      subject do
+        -> {
+          Team.sync(remote_attrs.take(2))
+          team.reload
+        }
+      end
+
+      it { should change { Team.count }.by(1) }
+      it { should change { Synchronizable::Import.count }.by(1) }
+
+      it { should change { team.name    }.from('x').to('y') }
+      it { should change { team.country }.from('Russia').to('USA') }
+      it { should change { team.city    }.from('Moscow').to('Washington') }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'database_cleaner'
+require 'factory_girl'
+require 'factory_girl_sequences'
+require 'spork'
+require 'simplecov'
+
+SimpleCov.start
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'synchronizable'
+
+require File.expand_path('../dummy/config/environment', __FILE__)
+require 'rspec/rails'
+
+support_pattern   = File.join(File.dirname(__FILE__), 'synchronizable', 'support', '**', '*.rb')
+factories_pattern = File.join(File.dirname(__FILE__), 'factories', '**', '*.rb')
+
+Dir[factories_pattern].each { |file| require file }
+Dir[support_pattern].each   { |file| require file }
+
+ActiveRecord::Migration.check_pending! if defined?(ActiveRecord::Migration)
+
+Spork.prefork do
+  RSpec.configure do |config|
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.run_all_when_everything_filtered = true
+    config.filter_run focus: true
+    config.order = 'random'
+    config.include FactoryGirl::Syntax::Methods
+
+    config.before(:suite) do
+      begin
+        FactoryGirl.lint
+      ensure
+        DatabaseCleaner.clean_with(:truncation)
+      end
+    end
+
+    config.before(:each) { DatabaseCleaner.strategy = :transaction }
+
+    config.before(:each, js: true) do
+      DatabaseCleaner.strategy = :truncation
+    end
+
+    config.before(:each) { DatabaseCleaner.start }
+    config.after(:each)  { DatabaseCleaner.clean }
+
+    if ENV['RUN_SLOW_TESTS'] != 'true'
+      config.filter_run_excluding slow: true
+    end
+  end
+
+  FactoryGirl.define do
+    %w(match team player match_player stage tournament).each do |model|
+      sequence(:"#{model}_id") { |n| "#{model}_#{n}" }
+    end
+  end
+end
+
+Spork.each_run do
+end

data/spec/synchronizable/dsl/macro_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Synchronizable::DSL::Macro do
+  describe 'commom attributes' do
+    subject { HasMacro }
+
+    before do
+      subject.xyz 7
+      subject.arr 1, 2, 3
+    end
+
+    it { respond_to? :foo }
+    it { respond_to? :bar }
+    it { respond_to? :baz }
+    it { respond_to? :xxx }
+    it { respond_to? :arr }
+
+    its(:foo) { should be nil  }
+    its(:bar) { should eq(1)   }
+    its(:baz) { should eq(2)   }
+    its(:xyz) { should eq('7') }
+    its(:arr) { should eq([1, 2, 3]) }
+  end
+
+  describe 'attribute with default value lambda that raises an error' do
+    it 'raises error' do
+      expect { HasMacro.carefull }.to raise_error(NotImplementedError)
+    end
+
+    context 'when overriden in subclass not to raise an error' do
+      subject { HasMacroSubclass }
+
+      it { respond_to? :foo }
+      it { respond_to? :bar }
+
+      its(:foo) { should be nil  }
+      its(:bar) { should eq(1)   }
+
+      it 'not raises error' do
+        expect { HasMacroSubclass.carefull }.to_not raise_error
+      end
+
+      it 'equals to the new default value' do
+        expect(HasMacroSubclass.carefull).to eq(0)
+      end
+    end
+  end
+
+  describe 'methods' do
+    subject { HasMacroSubclass }
+
+    it { respond_to? :sqr }
+    its(:sqr) { respond_to? :call }
+
+    it "sqr method definition returns square of two numbers" do
+      expect(subject.sqr.(2)).to eq(4)
+    end
+  end
+end

data/spec/synchronizable/models/import_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Synchronizable::Import do
+  let!(:team) { create :team }
+  subject     { create(:import, synchronizable: team) }
+
+  it 'destroys itself with synchronizable record' do
+    expect { subject.destroy_with_synchronizable }.to change(Team, :count).by(-1)
+  end
+end

data/spec/synchronizable/support/has_macro.rb

@@ -0,0 +1,12 @@
+class HasMacro
+  include Synchronizable::DSL::Macro
+
+  attribute :bar, default: 1
+  attribute :foo
+  attribute :baz, default: -> { bar + 1 }
+  attribute :carefull, default: -> { raise NotImplementedError }
+  attribute :xyz, converter: ->(x) { x.to_s }
+  attribute :arr
+
+  method :sqr
+end

data/spec/synchronizable/support/has_macro_subclass.rb

@@ -0,0 +1,9 @@
+require_relative 'has_macro'
+
+class HasMacroSubclass < HasMacro
+  attribute :carefull, default: 0
+
+  sqr do |x|
+    x * x
+  end
+end

data/spec/synchronizable/synchronizable_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Synchronizable do
+  describe 'synchronization' do
+    subject do
+      -> { Synchronizable.sync }
+    end
+
+    describe 'models specified in configuration' do
+      context 'only Team and Match' do
+        before :all do
+          Synchronizable.models = %w(Match Team)
+        end
+
+        it { should change { Match.count }.by(1) }
+        it { should change { Team.count }.by(2) }
+        it { should change { Player.count }.by(4) }
+        it { should change { MatchPlayer.count }.by(4) }
+
+        it { should change { Synchronizable::Import.count }.by(11) }
+      end
+
+      context 'all' do
+        before :all do
+          Synchronizable.models = %w(
+            Stage Tournament Team
+            Match MatchPlayer Player
+          )
+        end
+
+        it { should change { Tournament.count }.by(1) }
+        it { should change { Stage.count }.by(2) }
+        it { should change { Match.count }.by(1) }
+        it { should change { Team.count }.by(2) }
+        it { should change { MatchPlayer.count }.by(4) }
+        it { should change { Player.count }.by(4) }
+
+        it { should change { Synchronizable::Import.count }.by(14) }
+      end
+
+      # TODO: Left here until :include option is implemented
+      #
+      # context 'when models setting is overriden in method call' do
+      #   before :all do
+      #     Synchronizable.models = %w(Team Match)
+      #   end
+
+      #   subject do
+      #     -> { Synchronizable.sync(Match, Player) }
+      #   end
+
+      #   it { should change { Match.count }.by(1) }
+      #   it { should change { Player.count }.by(22) }
+      #   it { should_not change { Team.count }.by(2) }
+
+      #   it { should change { Synchronizable::Import.count }.by(5) }
+      # end
+    end
+  end
+end