mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/actor/binding_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Mutest::Actor::Binding do
+  let(:actor_a)    { instance_double(Mutest::Actor::Mailbox, sender: sender_a, receiver: receiver_a) }
+  let(:sender_a)   { instance_double(Mutest::Actor::Sender)                                          }
+  let(:sender_b)   { instance_double(Mutest::Actor::Sender)                                          }
+  let(:receiver_a) { instance_double(Mutest::Actor::Receiver)                                        }
+  let(:payload)    { instance_double(Object)                                                         }
+  let(:type)       { instance_double(Symbol)                                                         }
+
+  let(:object) { described_class.new(actor_a, sender_b) }
+
+  describe '#call' do
+    subject { object.call(type) }
+
+    before do
+      expect(sender_b).to receive(:call).with(message(type, sender_a)).ordered
+      expect(receiver_a).to receive(:call).ordered.and_return(message(response_type, payload))
+    end
+
+    context 'when return type equals request type' do
+      let(:response_type) { type }
+      it { is_expected.to be(payload) }
+    end
+
+    context 'when return type NOT equals request type' do
+      let(:response_type) { double('Other Type') }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Mutest::Actor::ProtocolError, "Expected #{type} but got #{response_type}")
+      end
+    end
+  end
+end

data/spec/unit/mutest/actor/env_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe Mutest::Actor::Env do
+  let(:thread)      { instance_double(Thread) }
+  let(:thread_root) { class_double(Thread)    }
+
+  let(:object) { described_class.new(thread_root) }
+
+  describe '#spawn' do
+    subject { object.spawn(&block) }
+
+    let!(:mailbox) { Mutest::Actor::Mailbox.new }
+
+    let(:yields) { [] }
+
+    let(:block) { ->(actor) { yields << actor } }
+
+    before do
+      expect(Mutest::Actor::Mailbox).to receive(:new).and_return(mailbox).ordered
+      expect(thread_root).to receive(:new).and_yield.and_return(thread).ordered
+    end
+
+    it 'returns sender' do
+      is_expected.to be(mailbox.sender)
+    end
+
+    it 'yields actor' do
+      expect { subject }.to change { yields }.from([]).to([mailbox])
+    end
+  end
+end

data/spec/unit/mutest/actor/mailbox_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe Mutest::Actor::Mailbox do
+  let(:mutex)              { instance_double(Mutex)             }
+  let(:condition_variable) { instance_double(ConditionVariable) }
+
+  before do
+    allow(Mutex).to receive(:new).and_return(mutex)
+    allow(ConditionVariable).to receive(:new).and_return(condition_variable)
+  end
+
+  describe '.new' do
+    subject { described_class.new }
+
+    its(:sender)   { is_expected.to eql(Mutest::Actor::Sender.new(condition_variable, mutex, []))   }
+    its(:receiver) { is_expected.to eql(Mutest::Actor::Receiver.new(condition_variable, mutex, [])) }
+  end
+
+  describe '#bind' do
+    subject { object.bind(other) }
+
+    let(:object) { described_class.new                    }
+    let(:other)  { instance_double(Mutest::Actor::Sender) }
+
+    it { is_expected.to eql(Mutest::Actor::Binding.new(object, other)) }
+  end
+end

data/spec/unit/mutest/actor/message_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Mutest::Actor::Message do
+  let(:type)    { instance_double(Symbol) }
+  let(:payload) { instance_double(Object) }
+
+  describe '.new' do
+    subject { described_class.new(*arguments) }
+
+    context 'with one argument' do
+      let(:arguments) { [type] }
+
+      its(:type)    { is_expected.to be(type)                     }
+      its(:payload) { is_expected.to be(Mutest::Actor::Undefined) }
+    end
+
+    context 'with two arguments' do
+      let(:arguments) { [type, payload] }
+
+      its(:type)    { is_expected.to be(type)    }
+      its(:payload) { is_expected.to be(payload) }
+    end
+  end
+end

data/spec/unit/mutest/actor/receiver_spec.rb

@@ -0,0 +1,56 @@
+RSpec.describe Mutest::Actor::Receiver do
+  let(:messages)           { instance_double(Array)             }
+  let(:mutex)              { instance_double(Mutex)             }
+  let(:condition_variable) { instance_double(ConditionVariable) }
+  let(:message)            { instance_double(Object)            }
+
+  let(:object) { described_class.new(condition_variable, mutex, messages) }
+
+  describe '#call' do
+    subject { object.call }
+
+    context 'when messages contains a message' do
+      before do
+        expect(mutex).to receive(:synchronize).and_yield.ordered
+        expect(messages).to receive(:empty?).and_return(false).ordered
+        expect(messages).to receive(:shift).and_return(message).ordered
+      end
+
+      it { is_expected.to be(message) }
+    end
+
+    context 'when messages initially contains no message' do
+      before do
+        # 1rst failing try
+        expect(mutex).to receive(:synchronize).and_yield.ordered
+        expect(messages).to receive(:empty?).and_return(true).ordered
+        expect(condition_variable).to receive(:wait).with(mutex).ordered
+        # 2nd successful try
+        expect(mutex).to receive(:synchronize).and_yield.ordered
+        expect(messages).to receive(:empty?).and_return(false).ordered
+        expect(messages).to receive(:shift).and_return(message).ordered
+      end
+
+      it 'waits for message' do
+        is_expected.to be(message)
+      end
+    end
+
+    context 'when messages contains no message but thread gets waken without message arrived' do
+      before do
+        # 1rst failing try
+        expect(mutex).to receive(:synchronize).and_yield.ordered
+        expect(messages).to receive(:empty?).and_return(true).ordered
+        expect(condition_variable).to receive(:wait).with(mutex).ordered
+        # 2nd failing try
+        expect(mutex).to receive(:synchronize).and_yield.ordered
+        expect(messages).to receive(:empty?).and_return(true).ordered
+        expect(condition_variable).to receive(:wait).with(mutex).ordered
+      end
+
+      it 'fails with error' do
+        expect { subject }.to raise_error(Mutest::Actor::ProtocolError)
+      end
+    end
+  end
+end

data/spec/unit/mutest/actor/sender_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Mutest::Actor::Sender do
+  let(:object) { described_class.new(condition_variable, mutex, messages) }
+
+  let(:condition_variable) { instance_double(ConditionVariable) }
+  let(:mutex)              { instance_double(Mutex)             }
+  let(:messages)           { instance_double(Array)             }
+  let(:type)               { instance_double(Symbol)            }
+  let(:payload)            { instance_double(Object)            }
+  let(:_message)           { message(type, payload)             }
+
+  describe '#call' do
+    subject { object.call(_message) }
+
+    before do
+      expect(mutex).to receive(:synchronize).ordered.and_yield
+      expect(messages).to receive(:<<).with(_message).ordered
+      expect(condition_variable).to receive(:signal).ordered
+    end
+
+    it_should_behave_like 'a command method'
+  end
+end

data/spec/unit/mutest/ast/meta/optarg_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe Mutest::AST::Meta::Optarg do
+  subject(:object) { described_class.new(node) }
+
+  let(:node)  { s(:optarg, name, value) }
+  let(:name)  { :foo                    }
+  let(:value) { s(:sym, :bar)           }
+
+  its(:name) { is_expected.to be(:foo) }
+  its(:default_value) { is_expected.to eql(s(:sym, :bar)) }
+
+  describe '#used?' do
+    subject { object.used? }
+
+    it { is_expected.to be true }
+
+    context 'when name is prefixed with an underscore' do
+      let(:name) { :_foo }
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/unit/mutest/ast/meta/send/proc_predicate_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Mutest::AST::Meta::Send, '#proc?' do
+  subject { described_class.new(node).proc? }
+
+  shared_context 'proc send' do |source|
+    let(:node) { Parser::CurrentRuby.parse(source).children.first }
+  end
+
+  shared_examples 'proc definition' do |*args|
+    include_context 'proc send', *args
+
+    it { is_expected.to be(true) }
+  end
+
+  shared_examples 'not a proc definition' do |*args|
+    include_context 'proc send', *args
+
+    it { is_expected.to be_falsey }
+  end
+
+  it_behaves_like 'proc definition', 'proc { }'
+  it_behaves_like 'proc definition', 'Proc.new { }'
+  it_behaves_like 'not a proc definition', 'new { }'
+  it_behaves_like 'not a proc definition', 'foo.proc { }'
+  it_behaves_like 'not a proc definition', 'Proc.blah { }'
+  it_behaves_like 'not a proc definition', 'Proc().new { }'
+  it_behaves_like 'not a proc definition', 'Foo.new { }'
+  it_behaves_like 'not a proc definition', 'blah { }'
+end

data/spec/unit/mutest/ast/meta/send/receiver_possible_top_level_const_predicate_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Mutest::AST::Meta::Send, '#receiver_possible_top_level_const?' do
+  subject { described_class.new(node).receiver_possible_top_level_const? }
+
+  def parse(source)
+    Parser::CurrentRuby.parse(source)
+  end
+
+  context 'when implicit top level const' do
+    let(:node) { parse('Foo.bar') }
+
+    it { is_expected.to be true }
+  end
+
+  context 'when cbase' do
+    let(:node) { parse('::Foo.bar') }
+
+    it { is_expected.to be true }
+  end
+
+  context 'when nested const' do
+    let(:node) { parse('Baz::Foo.bar') }
+
+    it { is_expected.to be false }
+  end
+
+  context 'when no receiver' do
+    let(:node) { parse('bar') }
+
+    it { is_expected.to be false }
+  end
+
+  context 'when send receiver' do
+    let(:node) { parse('foo.bar') }
+
+    it { is_expected.to be false }
+  end
+end

data/spec/unit/mutest/ast/meta/send_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Mutest::AST::Meta::Send do
+  let(:object) { described_class.new(node) }
+
+  def parse(source)
+    Parser::CurrentRuby.parse(source)
+  end
+
+  let(:method_call)            { parse('foo.bar(baz)')  }
+  let(:attribute_read)         { parse('foo.bar')       }
+  let(:index_assignment)       { parse('foo[0] = bar')  }
+  let(:attribute_assignment)   { parse('foo.bar = baz') }
+  let(:binary_method_operator) { parse('foo == bar')    }
+
+  class Expectation
+    include Adamantium, Anima.new(:name, :assignment, :attribute_assignment, :index_assignment, :binary_method_operator)
+
+    ALL = [
+      [:method_call,            false, false, false, false],
+      [:attribute_read,         false, false, false, false],
+      [:index_assignment,       true,  false, true,  false],
+      [:attribute_assignment,   true,  true,  false, false],
+      [:binary_method_operator, false, false, false, true]
+    ].map do |values|
+      new(Hash[anima.attribute_names.zip(values)])
+    end.freeze
+  end # Expectation
+
+  # Rspec should have a build in for this kind of "n-dimensional assertion with context"
+  (Expectation.anima.attribute_names - %i[name]).each do |name|
+    describe "##{name}?" do
+      subject { object.public_send(:"#{name}?") }
+
+      Expectation::ALL.each do |expectation|
+        context "on #{expectation.name}" do
+          let(:node) { public_send(expectation.name) }
+
+          it { is_expected.to be(expectation.public_send(name)) }
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutest/ast/named_children_spec.rb

@@ -0,0 +1,87 @@
+RSpec.describe Mutest::AST::NamedChildren do
+  describe '.included' do
+    let(:klass) do
+      Class.new do
+        include Mutest::AST::NamedChildren, Concord.new(:node)
+
+        children :foo, :bar
+      end
+    end
+
+    def publish
+      klass.class_eval do
+        public :foo, :bar
+
+        public :remaining_children, :remaining_children_indices, :remaining_children_with_index
+      end
+    end
+
+    let(:instance) { klass.new(node) }
+
+    let(:node_foo) { s(:foo) }
+    let(:node_bar) { s(:bar) }
+    let(:node_baz) { s(:baz) }
+
+    let(:node) { s(:node, node_foo, node_bar, node_baz) }
+
+    describe 'generated methods' do
+      specify 'are private by default' do
+        %i[
+          foo
+          bar
+          remaining_children
+          remaining_children_indices
+          remaining_children_with_index
+        ].each do |name|
+          expect(klass.private_instance_methods.include?(name)).to be(true)
+        end
+      end
+
+      describe '#remaining_children' do
+        it 'returns remaining unnamed children' do
+          publish
+          expect(instance.remaining_children).to eql([node_baz])
+        end
+      end
+
+      describe '#remaining_children_indices' do
+        it 'returns remaining unnamed children indices' do
+          publish
+          expect(instance.remaining_children_indices).to eql([2])
+        end
+      end
+
+      describe '#remaining_children_with_index' do
+        it 'returns remaining unnamed children indices' do
+          publish
+          expect(instance.remaining_children_with_index).to eql([[node_baz, 2]])
+        end
+      end
+
+      describe '#foo' do
+        it 'returns named child foo' do
+          publish
+          expect(instance.foo).to be(node_foo)
+        end
+      end
+
+      describe '#bar' do
+        context 'when node is present' do
+          it 'returns named child bar' do
+            publish
+            expect(instance.bar).to be(node_bar)
+          end
+        end
+
+        context 'when node is NOT present' do
+          let(:node) { s(:node, node_foo) }
+
+          it 'returns nil' do
+            publish
+            expect(instance.bar).to be(nil)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutest/ast/regexp/parse_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Mutest::AST::Regexp, '.parse' do
+  it 'parses using minor ruby version' do
+    expect(described_class.parse(/foo/).to_re).to eql(/foo/)
+  end
+end

data/spec/unit/mutest/ast/regexp/supported_predicate_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Mutest::AST::Regexp, '.supported?' do
+  subject { described_class.supported?(expression) }
+
+  let(:expression) { described_class.parse(regexp) }
+  let(:regexp)     { /foo/                         }
+
+  it { is_expected.to be(true) }
+
+  context 'conditional regular expressions' do
+    let(:regexp) { /((?(1)(foo)(bar)))/ }
+
+    it { is_expected.to be(false) }
+  end
+end

data/spec/unit/mutest/ast/regexp/transformer/lookup_table/table_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe Mutest::AST::Regexp::Transformer::LookupTable::Table do
+  subject { table.lookup(:regexp_fake_thing) }
+
+  let(:expression_class) { class_double(Regexp::Expression) }
+
+  let(:table) do
+    described_class.create(
+      [:regexp_fake_thing, %i[thing fake], expression_class]
+    )
+  end
+
+  its(:token) { is_expected.to eql(Regexp::Token.new(:thing, :fake)) }
+
+  its(:regexp_class) { is_expected.to be(expression_class) }
+
+  it 'exposes list of types' do
+    expect(table.types).to eql([:regexp_fake_thing])
+  end
+end