locomotivecms_steam 0.1.2.pre.beta → 1.0.0.pre.alpha

data/spec/unit/adapters/memory/condition_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+require_relative '../../../../lib/locomotive/steam/adapters/memory/condition.rb'
+
+describe Locomotive::Steam::Adapters::Memory::Condition do
+
+  let(:title)     { instance_double('Title', translations: { en: 'Awesome Site' }, :[] => 'Awesome Site') }
+  let(:entry)     { instance_double('Site', { title: title, content: 'foo' }) }
+  let(:locale)    { :en }
+  let(:field)     { :title }
+  let(:operator)  { :eq }
+  let(:name)      { "#{field}.#{operator}"}
+  let(:value)     { 'Awesome Site' }
+
+  subject { Locomotive::Steam::Adapters::Memory::Condition.new(name, value, locale) }
+
+  describe '#entry_value' do
+    context 'i18n' do
+      let(:name)  { 'title.eq' }
+      let(:value) { 'Awesome Site' }
+
+      context 'single entry' do
+        specify('match') do
+          expect(subject.matches?(entry)).to eq true
+        end
+
+        specify('return value') do
+          expect(subject.send(:entry_value, entry)).to eq(value)
+        end
+      end
+    end
+    context 'regular way' do
+      let(:name)  { 'content.eq' }
+      let(:value) { 'foo' }
+
+      context 'single entry' do
+        specify('should be match') do
+          expect(subject.matches?(entry)).to eq true
+        end
+
+        specify('return value') do
+          expect(subject.send(:entry_value, entry)).to eq(value)
+        end
+      end
+    end
+  end
+
+  describe '#decode_operator_and_field!' do
+    before { subject.send(:decode_operator_and_field!) }
+
+    context 'with normal value' do
+      specify('name should be left part of dot') { expect(subject.field).to eq(field) }
+      specify('operator should be right part of dot') { expect(subject.operator).to eq(operator) }
+      specify('right_operand should be value') { expect(subject.value).to eq(value) }
+    end
+
+    context 'with regex value' do
+      let(:value) { /^[a-z]$/ }
+      specify('operator should be matchtes') { expect(subject.operator).to eq(:matches) }
+    end
+  end
+
+  describe '#decode_operator_and_field!' do
+    context 'with unsupported operator' do
+      let(:name) { 'domains.unsupported' }
+      specify('should be throw Exception') do
+        expect do
+          subject.send(:decode_operator_and_field!)
+        end.to raise_error Locomotive::Steam::Adapters::Memory::Condition::UnsupportedOperator
+      end
+    end
+  end
+
+  describe '#adapt_operator!' do
+    let(:name) { 'domains.==' }
+    before do
+      subject.send(:decode_operator_and_field!)
+      subject.send(:adapt_operator!, value)
+    end
+    context 'with single value' do
+      let(:value) { 'sample.example.com' }
+      specify('operator should be :==') { expect(subject.operator).to eq(:==) }
+    end
+    context 'with array of values' do
+      let(:value) { ['sample.example.com'] }
+      specify('operator should be :in') { expect(subject.operator).to eq(:in) }
+    end
+  end
+
+  describe '#array_contains?' do
+    let(:source) { [1, 2, 3, 4] }
+    let(:target) { [1, 2, 3] }
+    context 'with target contains in source' do
+      specify('should be true') do
+        expect(subject.send(:array_contains?, source, target)).to eq true
+      end
+    end
+  end
+
+  describe '#value_in_right_operand?' do
+    context 'value contains in right operand' do
+      let(:value) { [1, 2, 3, 4] }
+      let(:right_operand) { [1, 2, 3] }
+
+      before do
+        allow(subject).to receive(:operator).and_return(operator)
+        allow(subject).to receive(:right_operand).and_return(right_operand)
+      end
+
+      context 'with operator :in' do
+        let(:operator) { :in }
+        specify('should return true') do
+          expect(subject.send(:value_is_in_entry_value?, value)).to eq true
+        end
+      end
+
+      context 'with other operator' do
+        let(:operator) { :nin }
+        specify('should not return true') do
+          expect(subject.send(:value_is_in_entry_value?, value)).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/unit/adapters/memory/dataset_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+require_relative '../../../../lib/locomotive/steam/adapters/memory/dataset.rb'
+
+describe Locomotive::Steam::Adapters::Memory::Dataset do
+
+  let(:john) do
+    {
+      firstname: 'John',
+      lastname: 'Doe',
+      email: 'john@example.com',
+      age: 24
+    }
+  end
+
+  let(:jane) do
+    {
+      firstname: 'Jane',
+      lastname: 'Doe',
+      email: 'jane@example.com',
+      age: 20
+    }
+  end
+
+  let(:alex) do
+    {
+      firstname: 'Alex',
+      lastname: 'Turam',
+      email: 'alex@example.com',
+      age: 26
+    }
+  end
+
+  subject { Locomotive::Steam::Adapters::Memory::Dataset.new(:foo) } #(loader) }
+
+  before do
+    [john.to_hash, jane.to_hash, alex.to_hash].each do |record|
+      subject.insert record
+    end
+  end
+
+  describe '#all' do
+    it { expect(subject.all).to eq [john.to_hash, jane.to_hash, alex.to_hash] }
+  end
+
+  describe '#find' do
+    specify do
+      expect(subject.find(john[:_id])).to eq(john.to_hash)
+    end
+  end
+
+  describe '#update' do
+    before do
+      subject.update(jane.to_hash.merge(lastname: 'birkin'))
+    end
+
+    specify do
+      expect(subject.find(jane[:_id]).fetch(:lastname)).to eq('birkin')
+    end
+  end
+
+  describe '#exists?' do
+    let(:dataset) { Locomotive::Steam::Adapters::Memory::Dataset.new(:dummy) }
+    before do
+      dataset.instance_variable_set('@records', { 1 => 'Record 1', 2 => 'Record 2' })
+    end
+
+    it { expect(dataset.exists?(2)).to eq true  }
+    it { expect(dataset.exists?(3)).to eq false  }
+    it { expect(dataset.exists?(nil)).to eq false  }
+
+  end
+end

data/spec/unit/adapters/memory/order_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+require_relative '../../../../lib/locomotive/steam/adapters/memory/order.rb'
+
+describe Locomotive::Steam::Adapters::Memory::Order do
+
+  let(:order) { Locomotive::Steam::Adapters::Memory::Order.new(*input) }
+
+  describe '#list' do
+
+    subject { order.list }
+
+    let(:input) { nil }
+    it { is_expected.to eq [] }
+
+    context 'via a string' do
+
+      let(:input) { 'name DESC' }
+      it { is_expected.to eq [[:name, :desc]] }
+
+    end
+
+    context 'via a hash with symbol directions' do
+
+      let(:input) { [{ name: :asc, date: :desc }] }
+      it { is_expected.to eq [[:name, :asc], [:date, :desc]] }
+
+    end
+
+    context 'via a string' do
+
+      let(:input) { 'name ASC, date DESC' }
+      it { is_expected.to eq [[:name, :asc], [:date, :desc]] }
+
+    end
+
+  end
+
+  describe '#apply_to' do
+
+    subject { order.apply_to(entry, :en) }
+
+    let(:input) { 'title asc, date desc' }
+    let(:entry) { instance_double('Entry', title: 'foo', date: Time.zone.now) }
+    it { expect(subject.map(&:class)).to eq([Locomotive::Steam::Adapters::Memory::Order::Asc, Locomotive::Steam::Adapters::Memory::Order::Desc]) }
+
+  end
+
+  describe 'sort' do
+
+    let(:array) {
+      [
+        instance_double('Entry1', id: 1, title: 'b', position: 1),
+        instance_double('Entry2', id: 2, title: 'b', position: 2),
+        instance_double('Entry3', id: 3, title: 'a', position: 3),
+        instance_double('Entry3', id: 4, title: 'c', position: 1)
+      ]
+    }
+    let(:input) { 'title asc, position desc' }
+
+    subject { array.sort_by { |entry| order.apply_to(entry, :en) } }
+
+    it { expect(subject.map(&:id)).to eq([3, 2, 1, 4]) }
+
+  end
+
+end

data/spec/unit/adapters/memory/query_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+require_relative '../../../../lib/locomotive/steam/adapters/memory/dataset.rb'
+require_relative '../../../../lib/locomotive/steam/adapters/memory/condition.rb'
+require_relative '../../../../lib/locomotive/steam/adapters/memory/order.rb'
+require_relative '../../../../lib/locomotive/steam/adapters/memory/query.rb'
+
+describe Locomotive::Steam::Adapters::Memory::Query do
+
+  let(:entry_1) { OpenStruct.new(name: 'foo', id: 1, attributes: { name: 'foo', id: 1 }) }
+  let(:entry_2) { OpenStruct.new(name: 'bar', id: 2, attributes: { name: 'bar', id: 2 }) }
+  let(:entry_3) { OpenStruct.new(name: 'zone', id: 3, attributes: { name: 'zone', id: 3 }) }
+  let(:records) { { 1 => entry_1, 2 => entry_2, 3 => entry_3 } }
+  let(:dataset) { Locomotive::Steam::Adapters::Memory::Dataset.new(:test) }
+  let(:locale)  { :en }
+
+  let(:query)   { Locomotive::Steam::Adapters::Memory::Query }
+
+  before { allow(dataset).to receive(:records).and_return(records) }
+
+  describe '#only' do
+    specify do
+      expect(
+        query.new(dataset, locale) do
+          only(:name)
+        end.all.map(&:name)
+      ).to eq(['foo', 'bar', 'zone'])
+    end
+  end
+
+  describe '#limited' do
+    specify do
+      expect(
+        query.new(dataset, locale) do
+          limit(1)
+        end.all
+      ).to eq([entry_1])
+    end
+  end
+
+  describe '#offset' do
+    specify do
+      expect(
+        query.new(dataset, locale) do
+          offset(1)
+        end.all.map(&:name)
+      ).to eq(['bar', 'zone'])
+    end
+  end
+
+  describe '#order_by' do
+
+    context 'asc' do
+      specify do
+        expect(
+          query.new(dataset, locale) do
+            order_by('name asc')
+          end.all.map(&:name)
+        ).to eq(['bar', 'foo', 'zone'])
+      end
+    end
+
+    context 'desc' do
+      specify do
+        expect(
+          query.new(dataset, locale) do
+            order_by('name desc')
+          end.all.map(&:name)
+        ).to eq(['zone', 'foo', 'bar'])
+      end
+    end
+  end
+
+  describe '#where' do
+    specify do
+      expect(
+        query.new(dataset, locale) do
+          where('name.eq' => 'foo').
+          where('id.lt' => 2)
+        end.all.map(&:name)
+      ).to eq(['foo'])
+    end
+  end
+
+end

data/spec/unit/adapters/memory_adapter_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+require_relative '../../../lib/locomotive/steam/adapters/memory.rb'
+
+describe Locomotive::Steam::MemoryAdapter do
+
+  let(:collection)  { [OpenStruct.new(name: 'Hello world')] }
+  let(:mapper)      { instance_double('Mapper', name: :test) }
+  let(:scope)       { instance_double('Scope', locale: nil) }
+  let(:adapter)     { Locomotive::Steam::MemoryAdapter.new(collection) }
+
+  before { allow(mapper).to receive(:to_entity) { |arg| arg } }
+
+  describe '#all' do
+
+    subject { adapter.all(mapper, scope) }
+    it { expect(subject.size).to eq 1 }
+
+  end
+
+  describe '#query' do
+
+    let(:block) { -> (_) { where(name: 'Hello world') } }
+    subject { adapter.query(mapper, scope, &block) }
+    it { expect(subject.size).to eq 1 }
+
+    context 'another syntax' do
+
+      let(:block) { -> (_) { where(k(:name, :in) => ['Hello world']) } }
+      it { expect(subject.size).to eq 1 }
+
+    end
+
+  end
+
+end

data/spec/unit/adapters/mongodb/query_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+require 'origin'
+
+require_relative '../../../../lib/locomotive/steam/adapters/mongodb/origin.rb'
+require_relative '../../../../lib/locomotive/steam/adapters/mongodb/query.rb'
+
+describe Locomotive::Steam::Adapters::MongoDB::Query do
+
+  let(:site)  { instance_double('Site', _id: 42) }
+  let(:scope) { instance_double('Scope', locale: :en, site: site) }
+  let(:localized_attributes) { [:title] }
+  let(:block) { nil }
+
+  let(:query) { Locomotive::Steam::Adapters::MongoDB::Query.new(scope, localized_attributes, &block) }
+
+  describe '#where' do
+
+    let(:criterion) { { fullpath: 'index' } }
+
+    context 'simple call' do
+
+      before { query.where(criterion) }
+
+      it { expect(query.criteria).to eq({ site_id: 42, fullpath: 'index' }) }
+
+    end
+
+    context 'chained' do
+
+      let(:another_criterion) { { published: true } }
+
+      before { query.where(criterion).where(another_criterion) }
+
+      it { expect(query.criteria).to eq({ site_id: 42, fullpath: 'index', published: true }) }
+
+    end
+
+  end
+
+  describe '#order_by' do
+
+    it { expect(query.order_by(title: :asc, published: :desc).sort).to eq [{title: :asc, published: :desc}] }
+
+  end
+
+  describe 'chaining where and order_by' do
+
+    before { query.where(published: true).order_by(title: :asc) }
+
+    it { expect(query.criteria).to eq({ site_id: 42, published: true }) }
+    it { expect(query.sort).to eq([{ title: :asc }]) }
+
+  end
+
+  describe '#to_origin' do
+
+    before { query.where(:title.in => %w(index)).only(:title, :published).order_by(title: :asc) }
+
+    subject { query.to_origin }
+
+    it { expect(subject.selector).to eq({ 'site_id' => 42, 'title.en' => { '$in' => %w(index) } }) }
+    it { expect(subject.options[:sort]).to eq({ 'title.en' => 1 }) }
+    it { expect(subject.options[:fields]).to eq({ 'title.en' => 1, 'published' => 1}) }
+
+  end
+
+end