nayati 0.1.0

data/spec/lib/decider_spec.rb

@@ -0,0 +1,4 @@
+RSpec.describe Nayati do
+  it 'Decides things' do
+  end
+end

data/spec/models/decider/master_operation_spec.rb

@@ -0,0 +1,26 @@
+module Nayati
+  RSpec.describe MasterOperation do
+
+    describe '#exists?' do
+      let(:master_workflow_name) { 'abcd_pqrs' }
+      let(:master_workflow) { MasterWorkflow.new(master_workflow_name) }
+      let(:operation_name) { 'operation_of_abcd_pqrs' }
+      context 'When operation is already present' do
+
+        subject { MasterOperation.new(master_workflow, operation_name).exists? }
+        it 'Returns true' do
+          allow(master_workflow).to receive(:operation_names) { [operation_name, 'some_other_operation_name'] }
+          expect(subject).to be_truthy
+        end
+      end
+
+      context 'When operation does not exist' do
+        subject { MasterOperation.new(master_workflow, operation_name).exists? }
+        it 'Returns false' do
+          allow(master_workflow).to receive(:operation_names) { ['some_other_operation_name'] }
+          expect(subject).to be_falsey
+        end
+      end
+    end
+  end
+end

data/spec/models/decider/master_workflow_spec.rb

@@ -0,0 +1,28 @@
+module Nayati
+  RSpec.describe MasterWorkflow do
+
+    describe '#exists?' do
+      let(:workflow_name) { 'abcd_pqrs' }
+      let(:master_workflow) { MasterWorkflow.new(workflow_name) }
+      context 'Operation configuration#workflow_names does not have workflow name' do
+
+        subject { master_workflow.exists? }
+        it 'Returns false' do
+          allow(Nayati::OperationConfiguration).to receive(:workflow_names) { [] }
+          expect(subject).to be_falsey
+        end
+      end
+
+      context 'Operation configuration#workflow_names does have workflow name' do
+        let(:workflow_name) { 'abcd_pqrs' }
+        let(:master_workflow) { MasterWorkflow.new(workflow_name) }
+
+        subject { master_workflow.exists? }
+        it 'Returns false' do
+          allow(Nayati::OperationConfiguration).to receive(:workflow_names) { [workflow_name.to_sym, :something_else] }
+          expect(subject).to be_truthy
+        end
+      end
+    end
+  end
+end

data/spec/models/decider/operation_spec.rb

@@ -0,0 +1,48 @@
+module Nayati
+  RSpec.describe Operation do
+    describe '#operation_implementer_klass_name' do
+      let(:operation) { create(:nayati_operation)}
+      subject { operation.operation_implementer_klass_name }
+
+      it 'Returns workflow namespaced klass name' do
+        expect(subject).to eq('DoingSomethingNayatiWorkflow::SomeOperationNayatiOperation')
+      end
+    end
+
+    describe '#build_implementer' do
+      let(:operation) { create(:nayati_operation)}
+      let(:context) { {} }
+      let(:workflow_result_object) { double }
+      let(:implementer_klass) { double }
+      let(:implementer_klass_name) { double }
+      let(:implementer_instance) { double }
+
+      subject { operation.build_implementer(context, workflow_result_object) }
+      it 'Returns implementer class' do
+        allow(operation).to receive(:operation_implementer_klass_name) { implementer_klass_name }
+        allow(implementer_klass_name).to receive(:constantize) { implementer_klass }
+        allow(implementer_klass).to receive(:new).with(context, workflow_result_object) { implementer_instance }
+        expect(subject).to eq(implementer_instance)
+        # allow()
+      end
+    end
+
+    describe 'associations' do
+      it { Operation.reflect_on_association(:after_success_operation).macro.should  eq(:belongs_to) }
+      it { Operation.reflect_on_association(:after_failure_operation).macro.should  eq(:belongs_to) }
+      it { Operation.reflect_on_association(:workflow).macro.should  eq(:belongs_to) }
+    end
+
+    describe '#validatoin' do
+      let(:workflow) { create(:nayati_workflow) }
+      let(:operation) { Nayati::Operation.new }
+      subject { operation.valid? }
+
+      it 'Returns false with proper error message' do
+        expect(subject).to be_falsey
+        expect(operation.errors.messages[:workflow]).to include('must exist')
+        expect(operation.errors.messages[:name]).to include("can't be blank")
+      end
+    end
+  end
+end

data/spec/models/decider/workflow_spec.rb

@@ -0,0 +1,159 @@
+require 'pry'
+module Nayati
+  RSpec.describe Workflow, type: :model do
+    describe '#name_space' do
+      let(:workflow) { create(:nayati_workflow)}
+
+      subject { workflow.name_space }
+      it 'Returens proper name space' do
+        expect(subject).to eq('doing_something')
+      end
+    end
+
+    describe '#klass_name' do
+      let(:workflow) { create(:nayati_workflow)}
+
+      subject { workflow.klass_name }
+      it 'Returns proper name space' do
+        expect(subject).to eq('DoingSomethingWorkflow')
+      end
+    end
+
+    describe '#klass' do
+      let(:workflow) { create(:nayati_workflow)}
+
+      subject { workflow.klass }
+
+      context 'Workflow running context is not set' do
+        it 'Raises an error' do
+          expect{subject}.to raise_error(Nayati::Workflow::ContextNotSetError)
+        end
+      end
+
+      let(:implementer_klass_name) { "DoingSomething" }
+      let(:implementer_klass) { double }
+      let(:implementer_klass_instance) { double }
+      let(:workflow_running_context) { double }
+      it 'Returns the implementer class instance of the workflow' do
+        workflow.context = workflow_running_context
+        allow(workflow).to receive(:klass_name) { implementer_klass_name }
+        expect(implementer_klass_name).to receive(:constantize) { implementer_klass }
+        expect(implementer_klass).to receive(:new).with(workflow_running_context) {implementer_klass_instance}
+        expect(subject).to eq(implementer_klass_instance)
+      end
+    end
+
+    describe '#specific_result_obj_klass_constant_name' do
+      let(:workflow) { create(:nayati_workflow) }
+      subject { workflow.specific_result_obj_klass_constant_name }
+
+      it 'Returns specific result object class name' do
+        expect(subject).to eq("Nayati::WorkflowResults::DoingSomethingWorkflow")
+      end
+    end
+
+    describe '#result_obj_klass' do
+      context 'Specific result class is present' do
+        let(:workflow) { create(:nayati_workflow) }
+        let(:result_klass) { double }
+        let(:result_klass_instance) { double }
+        subject { workflow.result_obj }
+        it 'Returns that class' do
+          allow(Module).to receive(:const_get).with(workflow.specific_result_obj_klass_constant_name) { result_klass }
+          allow(result_klass).to receive(:new) { result_klass_instance }
+          expect(subject).to eq(result_klass_instance)
+        end
+      end
+
+      context 'Specific result class is absent' do
+        let(:workflow) { create(:nayati_workflow) }
+        subject { workflow.result_obj }
+        it 'Returns that class' do
+          expect(subject).to be_an_instance_of(Nayati::WorkflowResults::Base)
+        end
+      end
+    end
+
+    describe '#specific_result_klass_present?' do
+      let(:workflow) { create(:nayati_workflow)}
+      subject { workflow.specific_result_klass_present? }
+
+      it 'Returns false if specific_result_klass is present?' do
+
+      end
+    end
+
+    describe '#result_obj' do
+      let(:workflow) { create(:nayati_workflow) }
+      context 'Workflow specific result object is present' do
+        it 'Returns that specific result object' do
+          # allow(Object).to receive(:const_defined?).with("Result"workflow.name)
+        end
+      end
+
+      context 'Workflow specific result object is not present' do
+        it 'Returns default result object' do
+        end
+      end
+    end
+
+    describe 'Validations' do
+      describe 'Creation' do
+        let(:workflow_name) { 'Some Name' }
+        let(:initial_operation_name) { 'First operation of the workflow' }
+
+        context 'Initial operation name is not passed' do
+          let(:workflow_creation_params) { { name: workflow_name } }
+          let(:workflow_obj) { Nayati::Workflow.new(workflow_creation_params) }
+          subject { workflow_obj.valid? }
+          it 'Adds proper error to workflow object' do
+            subject
+            expect(workflow_obj.errors[:initial_operation_name]).to include("Please set initial_operation_name")
+          end
+        end
+
+        context 'initial_operation_name is passed' do
+          let(:workflow_creation_params) { { name: workflow_name, initial_operation_name: initial_operation_name } }
+          let(:workflow_obj) { Nayati::Workflow.new(workflow_creation_params) }
+
+          subject { workflow_obj.valid? }
+          it 'Returns true' do
+            expect(subject).to be_truthy
+          end
+        end
+      end
+    end
+
+    describe 'Workflow object persistance' do
+      let(:workflow_name) { 'Some Name' }
+      let(:initial_operation_name) { 'First operation of the workflow' }
+
+      context 'Workflow object is valid' do
+        describe 'Creation' do
+          let(:workflow_creation_params) { { name: workflow_name, initial_operation_name: initial_operation_name } }
+          let(:workflow_obj) { Nayati::Workflow.new(workflow_creation_params) }
+
+          subject { workflow_obj.save }
+          it 'Persists workfow record' do
+            expect{subject}.to change{Nayati::Workflow.where(name: workflow_name).count}.by(1)
+          end
+
+          subject { workflow_obj.save }
+          it 'Creates initial operation record' do
+            expect{subject}.to change{Nayati::Operation.count}.by(1)
+            expect(workflow_obj.reload.initial_operation.name).to eq('first_operation_of_the_workflow')
+          end
+        end
+      end
+    end
+
+    describe '#self.assign_from_creation_params' do
+      let(:params) { { name: 'some_workflow_name', initial_operation_name: 'some_operation_name' } }
+      subject { Workflow.assign_from_creation_params(params) }
+      it 'Assigns from params' do
+        expect(subject.initial_operation_name).to eq('some_operation_name')
+        expect(subject.name).to eq('some_workflow_name')
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,57 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+require 'spec_helper'
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../../config/environment', __FILE__)
+# Prevent database truncation if the environment is production
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+require 'rspec/rails'
+# Add additional requires below this line. Rails is not loaded until this point!
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
+
+# Checks for pending migrations and applies them before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # RSpec Rails can automatically mix in different behaviours to your tests
+  # based on their file location, for example enabling you to call `get` and
+  # `post` in specs under `spec/controllers`.
+  #
+  # You can disable this behaviour by removing the line below, and instead
+  # explicitly tag your specs with their type, e.g.:
+  #
+  #     RSpec.describe UsersController, :type => :controller do
+  #       # ...
+  #     end
+  #
+  # The different available types are documented in the features, such as in
+  # https://relishapp.com/rspec/rspec-rails/docs
+  config.infer_spec_type_from_file_location!
+
+  # Filter lines from Rails gems in backtraces.
+  config.filter_rails_from_backtrace!
+  # arbitrary gems may also be filtered via:
+  # config.filter_gems_from_backtrace("gem name")
+end

data/spec/spec_helper.rb

@@ -0,0 +1,120 @@
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+ENGINE_RAILS_ROOT = File.join(File.dirname(__FILE__), '../')
+
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'factory_girl'
+# require '../factories/workflow_factory'
+
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+# Load factories
+Dir["#{File.dirname(__FILE__)}/factories/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.include Nayati::Engine.routes.url_helpers
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.include FactoryGirl::Syntax::Methods
+  config.order = "random"
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end