marty 0.5.15 → 0.5.16

data/spec/models/posting_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+module Marty
+  describe Posting do
+    describe "validations" do
+      it "requires unique names" do
+        dt = "20130215 0800"
+        c = Posting.count
+        Posting.do_create("BASE", dt, 'a comment')
+        Posting.count.should == c + 1
+        expect { s = Posting.do_create("BASE", dt, 'a comment') }.
+          to raise_error(ActiveRecord::RecordInvalid)
+      end
+
+      it "creates name based on PDT" do
+        d, t, tz = "20130215", "0900", "PST8PDT"
+        dt_tz = [d, t, tz].join(' ')
+        p = Posting.do_create("BASE", dt_tz, 'a comment')
+        expect(p.name).to match /BASE-#{d}-#{t}/
+        p.reload
+        expect(p.created_dt).to eq Time.zone.parse(dt_tz)
+      end
+    end
+
+    describe "lookups" do
+      it "are seeded with a NOW posting" do
+        expect(Posting.lookup_dt("NOW")).to eq Float::INFINITY
+      end
+
+      describe ".get_latest" do
+        it "provide a list of latest of postings in descending order" do
+          4.times { |d|
+            Posting.do_create("BASE", d.day.from_now, 'a comment')
+          }
+          dt3 = 3.day.from_now
+
+          latest = Posting.get_latest(1)
+          expect(latest.count).to eq 1
+          expect(latest[0].name).to match /BASE-#{dt3.strftime("%Y%m%d-%H%M")}/
+        end
+      end
+
+      describe ".get_latest_by_type" do
+        context "when invalid parameters are supplied" do
+          it "raises 'posting type list missing' error" do
+            expect { Posting.get_latest_by_type(10, nil) }.
+              to raise_error "missing posting types list"
+          end
+
+          it "raises 'bad posting types list' error" do
+            expect { Posting.get_latest_by_type(10, 'BASE') }.
+              to raise_error "bad posting types list"
+          end
+        end
+
+        context "when valid parameters are supplied" do
+          before do
+            PostingType.create({name: 'SNAPSHOT'})
+            PostingType.create({name: 'OTHER'})
+            Posting.do_create("BASE",     0.day.from_now, 'base posting')
+            Posting.do_create("SNAPSHOT", 1.day.from_now, 'snapshot1 posting')
+            Posting.do_create("SNAPSHOT", 2.day.from_now, 'snapshot2 posting')
+            Posting.do_create("OTHER"   , 3.day.from_now, 'other1 posting')
+            Posting.do_create("SNAPSHOT", 4.day.from_now, 'snapshot3 posting')
+            Posting.do_create("OTHER"   , 5.day.from_now, 'other2 posting')
+          end
+
+          it "filters on a single posting type" do
+            # First param is just the limit (max) to return
+            res = Posting.get_latest_by_type(10, ['BASE'])
+            expect(res.count).to eq 1
+            expect(res[0].comment).to eq 'base posting'
+          end
+
+          it "filters on multiple posting types" do
+            res = Posting.get_latest_by_type(10, ['BASE', 'SNAPSHOT'])
+            expect(res.count).to eq 4
+            # snapshot3 is most recent with this filter
+            expect(res[0].comment).to eq 'snapshot3 posting'
+            expect(res[3].comment).to eq 'base posting'
+          end
+
+          it "filters on posting types that are single or double quoted" do
+            res = Posting.get_latest_by_type(10, ['SNAPSHOT', "OTHER"])
+            expect(res.count).to eq 5
+            # other2 is most recent with this filter
+            expect(res[0].comment).to eq 'other2 posting'
+            expect(res[4].comment).to eq 'snapshot1 posting'
+          end
+
+          it "filters and limits on multiple posting types" do
+            res = Posting.get_latest_by_type(3, ['SNAPSHOT', 'OTHER'])
+            expect(res.count).to eq 3
+            # other2 is most recent with this filter
+            expect(res[0].comment).to eq 'other2 posting'
+            expect(res[2].comment).to eq 'other1 posting'
+          end
+
+          it "returns nothing with an empty posting type list" do
+            res = Posting.get_latest_by_type(10, [])
+            expect(res.count).to eq 0
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/promise_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'marty'
+require 'delorean_lang'
+require 'job_helper'
+
+describe Marty::Promise, slow: true do
+  before(:all) do
+    @clean_file = "/tmp/clean_#{Process.pid}.psql"
+    save_clean_db(@clean_file)
+    # transactional fixtures interfere with queueing jobs
+    self.use_transactional_fixtures = false
+
+    # Needed here because shutting transactional fixtures off
+    # means we lose the globally set user
+    Mcfly.whodunnit = UserHelpers.system_user
+
+    Marty::Script.load_script_bodies(promise_bodies, Date.today)
+
+    start_delayed_job
+  end
+
+  before(:each) do
+    @time = DateTime.now
+    expect(Marty::Promise.unscoped.count).to eq(0)
+    engine = Marty::ScriptSet.new.get_engine(NAME_A)
+    engine.background_eval("Y", {"p_title" => NAME_A}, ["d"])
+    sleep 5
+    Marty::Promise.cleanup
+    expect(Marty::Promise.unscoped.count).to eq(10)
+  end
+
+  after(:each) do
+    Marty::Promise.where('parent_id IS NULL').destroy_all
+    Timecop.return
+  end
+
+  after(:all) do
+    restore_clean_db(@clean_file)
+    stop_delayed_job
+  end
+
+  it "should retain jobs that were run less than 4 hours ago" do
+    Timecop.freeze(@time + 4.hours)
+    Marty::Promise.cleanup
+    expect(Marty::Promise.unscoped.count).to eq(10)
+  end
+
+  it "should cleanup jobs that are older than 4 hours" do
+    Timecop.freeze(@time + 4.hours + 1.minute)
+    Marty::Promise.cleanup
+    expect(Marty::Promise.unscoped.count).to eq(0)
+  end
+
+  it "should allow cleanup of all jobs when forced by admin" do
+    Timecop.freeze(@time + 4.hours)
+    Marty::Promise.cleanup(true)
+    expect(Marty::Promise.unscoped.count).to eq(0)
+  end
+
+  it "should provide a live search scope for filtering by user or role" do
+    expect(Marty::Promise.live_search('XXX').size).to eq(0)
+    expect(Marty::Promise.live_search('marty').size).to eq(10)
+    expect(Marty::Promise.live_search('Admin').size).to eq(10)
+  end
+end

data/spec/models/script_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+s1 =<<eof
+NodeA:
+  attr = 123
+eof
+
+s2 =<<eof
+NodeB:
+  attr = 456
+eof
+
+describe Marty::Script do
+  describe '.load_a_script' do
+    let(:now) { Time.zone.now - 1.minute }
+
+    it "creates a new script if it doesn't already exist" do
+      expect { Marty::Script.load_a_script('TestNew', s1, now) }.
+        to change(Marty::Script, :count).by(1)
+      expect(Marty::Script.lookup('infinity', 'TestNew').created_dt.to_s).
+        to eq(now.to_s)
+    end
+
+    it "doesn't create a new script entry if it already exists and is the " +
+      "same as the existing" do
+      Marty::Script.load_a_script('TestExistsAndSame', s1)
+      expect { Marty::Script.load_a_script('TestExistsAndSame', s1) }.
+        not_to change(Marty::Script, :count)
+    end
+
+    it 'updates the existing script entry if it already exists but is ' +
+      'different' do
+      Marty::Script.load_a_script('TestExistsAndDifferent1', s1)
+      expect { Marty::Script.load_a_script('TestExistsAndDifferent1', s2) }.
+        to change(Marty::Script, :count).by(1)
+
+      Marty::Script.load_a_script('TestExistsAndDifferent2', s1, now - 1.minute)
+      expect { Marty::Script.load_a_script('TestExistsAndDifferent2',
+                                           s2, now) }.
+        to change { Marty::Script.where(name: 'TestExistsAndDifferent2',
+                                        obsoleted_dt: 'infinity').count }.by(0)
+      expect(Marty::Script.lookup('infinity', 'TestExistsAndDifferent2').
+             created_dt.to_s).to eq(now.to_s)
+    end
+  end
+
+  describe '.load_script_bodies' do
+    before(:each) do
+      allow(Marty::Script).to receive(:load_a_script)
+    end
+
+    let(:now) { Time.zone.now - 1.minute }
+
+    it 'loads each script given a hash' do
+      Marty::Script.load_script_bodies({'Test1' => s1, 'Test2' => s2}, now)
+      expect(Marty::Script).to have_received(:load_a_script).
+        with('Test1', s1, now)
+      expect(Marty::Script).to have_received(:load_a_script).
+        with('Test2', s2, now)
+      expect(Marty::Script).to have_received(:load_a_script).twice
+    end
+
+    it 'loads each script given an array of tuples' do
+      Marty::Script.load_script_bodies([['Test1', s1], ['Test2', s2]], now)
+      expect(Marty::Script).to have_received(:load_a_script).
+        with('Test1', s1, now)
+      expect(Marty::Script).to have_received(:load_a_script).
+        with('Test2', s2, now)
+      expect(Marty::Script).to have_received(:load_a_script).twice
+    end
+
+    it 'creates a new tag if none exist yet with provided datetime' do
+      expect { @tag = Marty::Script.load_script_bodies({'Test1' => s1,
+                                                        'Test2' => s2}, now) }.
+        to change(Marty::Tag, :count).by(1)
+      expect(@tag.created_dt).to eq(now + 1.second)
+    end
+
+    it 'creates a new tag when there is an older one present' do
+      Marty::Tag.do_create(now - 1.minute, 'initial test tag')
+      expect { @tag = Marty::Script.load_script_bodies({'Test1' => s1,
+                                                        'Test2' => s2}, now) }.
+        to change(Marty::Tag, :count).by(1)
+      expect(@tag.created_dt).to eq(now + 1.second)
+    end
+
+    it 'creates a new tag when no previous tag is present and no datetime ' +
+      'provided' do
+      expect { tag = Marty::Script.load_script_bodies({'Test1' => s1,
+                                                       'Test2' => s2}) }.
+        to change(Marty::Tag, :count).by(1)
+    end
+
+    it "doesn't create a new tag if one is present and the script wasn't" +
+      "modified" do
+      Marty::Script.create!(name: 'Test1', body: s1, created_dt: now)
+      Marty::Tag.do_create(now + 1.second, 'tag created by test')
+      expect { Marty::Script.load_script_bodies({'Test1' => s1}) }.
+        not_to change(Marty::Tag, :count)
+    end
+  end
+
+  describe '.load_scripts' do
+    before(:each) do
+      allow(Marty::Script).to receive(:load_script_bodies)
+    end
+
+    let(:scripts_path) do
+      File.expand_path('../../fixtures/scripts/load_tests', __FILE__)
+    end
+    let(:now) { Time.zone.now - 1.minute }
+    let(:ls1) { File.read("#{scripts_path}/script1.dl") }
+    let(:ls2) { File.read("#{scripts_path}/script2.dl") }
+
+    it 'reads in the files and loads the script bodies' do
+      Marty::Script.load_scripts(scripts_path, now)
+      expect(Marty::Script).to have_received(:load_script_bodies).
+        with(match_array([['Script1', ls1], ['Script2', ls2]]), now)
+    end
+
+  end
+
+  describe '.get_script_filenames' do
+    context 'with single directory passed in' do
+      before(:each) do
+        allow(Dir).to receive(:glob).and_return(script_files)
+      end
+
+      let(:script_files) { ['/test/script1.dl', '/test/script2.dl'] }
+
+      it 'gets the files from the specified directory' do
+        Marty::Script.get_script_filenames('/test')
+        expect(Dir).to have_received(:glob).with('/test/*.dl')
+      end
+
+      it 'returns the files in the given directory' do
+        expect(Marty::Script.get_script_filenames('/test')).
+          to match_array(script_files)
+      end
+    end
+
+    context 'with duplicate script file names' do
+      it 'returns only the unique file names' do
+        allow(Dir).to receive(:glob).with('/test1/*.dl').
+          and_return(['/test1/sc1.dl', '/test1/sc2.dl'])
+        allow(Dir).to receive(:glob).with('/test2/*.dl').
+          and_return(['/test2/sc2.dl', '/test2/sc3.dl'])
+        expect(Marty::Script.get_script_filenames(['/test1', '/test2'])).
+          to match_array(['/test1/sc1.dl', '/test1/sc2.dl', '/test2/sc3.dl'])
+      end
+    end
+
+    context 'using default directories' do
+      it 'gets the files from the default paths' do
+        allow(Dir).to receive(:glob).and_return([])
+        Marty::Script.get_script_filenames
+        expect(Dir).to have_received(:glob).with("#{Rails.root}/delorean/*.dl")
+        expect(Dir).to have_received(:glob).
+          with(File.expand_path('../../../delorean/*.dl', __FILE__))
+        expect(Dir).to have_received(:glob).twice
+      end
+    end
+
+    context 'with Rails.configuration.marty.delorean_scripts_path' do
+      before(:each) do
+        Rails.configuration.marty.delorean_scripts_path = ['/conf_test']
+      end
+      after(:each) { Rails.configuration.marty.delorean_scripts_path = nil }
+
+      it 'gets the files from the specified path' do
+        allow(Dir).to receive(:glob).and_return([])
+        Marty::Script.get_script_filenames
+        expect(Dir).to have_received(:glob).with('/conf_test/*.dl')
+      end
+    end
+  end
+
+  describe '.delete_scripts' do
+    it 'removes all the scripts' do
+      Marty::Script.create!(name: 'TestScript1', body: s1)
+      Marty::Script.create!(name: 'TestScript2', body: s2)
+
+      Marty::Script.delete_scripts
+      expect(Marty::Script.count).to eq(0)
+    end
+  end
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Marty
+  describe User do
+    before(:each) do
+      Rails.configuration.marty.system_account =
+        UserHelpers.system_user.login
+    end
+
+    let (:tuser) {
+      UserHelpers.create_user('other_user')
+    }
+
+    describe "validations" do
+      it "should require login, firstname and lastname" do
+        user = User.new
+        expect(user).to_not be_valid
+        expect(user.errors[:login].any?).to be true
+        expect(user.errors[:firstname].any?).to be true
+        expect(user.errors[:lastname].any?).to be true
+      end
+
+      it "should require unique login" do
+        expect(Mcfly.whodunnit).to_not be_nil
+        user = UserHelpers.system_user.dup
+        expect(user).to_not be_valid
+        expect(user.errors[:login].to_s).to include('already been taken')
+        user.login = 'marty2'
+        expect(user).to be_valid
+      end
+
+      it "should not allow Gemini account to be de-activated" do
+        user = UserHelpers.system_user
+        user.active = false
+        expect(user).to_not be_valid
+        expect(user.errors[:base].to_s).
+          to include('application system account cannot be deactivated')
+      end
+
+      it "should not allow accounts to be deleted" do
+        user = UserHelpers.system_user
+        user.destroy
+        expect(user.destroyed?).to be false
+      end
+
+      it "should not allow user managers to edit the Gemini account" do
+        Mcfly.whodunnit = tuser
+        user = UserHelpers.system_user
+        allow_any_instance_of(Marty::User).to receive(:user_manager_only).
+          and_return(true)
+        user.firstname = 'Testing'
+        expect(user).to_not be_valid
+        expect(user.errors[:base].to_s).
+          to include('cannot edit the application system account')
+      end
+
+      it "should not allow user managers to edit their own account" do
+        Mcfly.whodunnit = tuser
+        allow_any_instance_of(Marty::User).to receive(:user_manager_only).
+          and_return(true)
+        tuser.firstname = 'Testing'
+        expect(tuser).to_not be_valid
+        expect(tuser.errors[:base].to_s).
+          to include('cannot edit or add additional roles')
+      end
+    end
+  end
+end

data/spec/requests/routes_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Marty Rails engine routes', type: :request do
+  it 'can reach the rpc endpoint' do
+    get marty.rpc_path(:evaluate, format: :json)
+    post marty.rpc_path(:evaluate, format: :json)
+  end
+
+  it 'can reach the jobs endpoint' do
+    get marty.job_path(:download)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+ENV["RAILS_ENV"] ||= "test"
+
+require 'dummy/config/application'
+require 'rspec/rails'
+require 'database_cleaner'
+
+Dummy::Application.initialize!
+
+ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)
+
+Dir[Rails.root.join("../support/**/*.rb")].each { |f| require f }
+
+class ActiveRecord::Base
+  mattr_accessor :shared_connection
+
+  def self.clear_connection
+    @@shared_connection = nil
+  end
+
+  clear_connection
+
+  def self.connection
+    @@shared_connection || retrieve_connection
+  end
+
+  def self.reset_shared_connection
+    @@shared_connection = retrieve_connection
+  end
+end
+
+ActiveRecord::Base.shared_connection = ActiveRecord::Base.connection
+
+RSpec.configure do |config|
+  config.include DelayedJobHelpers
+  config.include CleanDbHelpers
+
+  # TODO: Continue to remove should syntax from specs - remove this line to see
+  # errors
+  config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
+
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+
+    Marty::Engine.load_seed
+    Rails.application.load_seed
+  end
+
+  config.before(:each) do
+    Mcfly.whodunnit = UserHelpers.system_user
+  end
+
+  config.infer_spec_type_from_file_location!
+  config.use_transactional_fixtures = true
+
+  Netzke::Testing.rspec_init(config)
+end