lanes 0.0.1

data/spec/concerns/pub_sub_spec.rb

@@ -0,0 +1,83 @@
+require_relative '../spec_helper'
+
+class PubSubTest < Lanes::TestCase
+
+    class EventTester
+        def self.after_save(*args);    end
+        def self.after_create(*args);  end
+        def self.after_update(*args);  end
+        def self.after_destroy(*args); end
+
+        include Lanes::Concerns::PubSub
+
+        def trigger( event, *args )
+            fire_event(event, *args )
+        end
+    end
+
+    class Ev1 < EventTester
+        has_additional_events :test_one
+    end
+
+    class Ev2 < EventTester
+        has_additional_events :test_two
+    end
+
+
+    def test_event_name_registration
+        assert_equal [ :save, :create, :update, :destroy ],EventTester.valid_event_names
+        assert_equal [ :save, :create, :update, :destroy, :test_one ],Ev1.valid_event_names
+    end
+
+    def test_only_valid
+        assert_raises( EventTester::InvalidEvent) do
+            EventTester.observe(:invalid_event) do | ev |
+            end
+        end
+        assert_raises( EventTester::InvalidEvent) do
+            EventTester.observe(:save) do | ev |
+            end
+            EventTester.new.trigger(:invalid_event)
+        end
+        assert_raises( EventTester::InvalidEvent) do
+            Ev1.observe(:test_two) do | ev |
+            end
+        end
+        assert_raises( EventTester::InvalidEvent) do
+            Ev2.observe(:test_one) do | ev |
+            end
+        end
+        begin
+            Ev2.observe(:test_one) do | ev |
+            end
+        rescue EventTester::InvalidEvent=>e
+            assert_equal 'test_one is not a valid event for PubSubTest::Ev2', e.to_s
+        end
+    end
+
+    def test_subscription
+        EventTester.observe(:save) do | ev |
+        end
+    end
+    def test_firing
+        results=[]
+        Ev1.observe(:test_one) do | ev, one, two |
+            results = [ ev, one, two ]
+        end
+        evt=Ev1.new
+        evt.trigger( :test_one, 3, 5 )
+        assert_equal [ evt, 3, 5 ], results
+
+        evt.trigger( :test_one, 'foo' )
+        assert_equal [ evt, 'foo', nil ], results
+    end
+
+
+    def test_firing_with_assertsions
+        assert_event_fires( Ev1, :test_one ) do
+            Ev1.new.trigger( :test_one, 3, 5 )
+        end
+        assert_equal [ 3, 5 ], last_event_results[1..-1]
+    end
+
+end

data/spec/concerns/set_attribute_data_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../spec_helper'
+
+class SetAttributeDataTest < Lanes::TestCase
+
+    include TestingModels
+
+    def test_attribute_access
+        tm = TestModel.new
+        assert tm.setting_attribute_is_allowed?(:name, lanes_users(:admin)), "can't access :name"
+        assert tm.can_write_attributes?({}, admin), "Can't write to TestModel"
+        data = { name: 'CASH', number: '1200' }
+        assert_equal( data, TestModel.new.set_attribute_data(data) )
+    end
+
+    def test_blacklisting
+        assert TestModel.new.setting_attribute_is_allowed?(:number,Lanes::User.current)
+        TestModel.send :blacklist_attributes, :number
+        assert_includes TestModel.blacklisted_attributes, :number
+        refute TestModel.new.setting_attribute_is_allowed?(:number, Lanes::User.current), "Allowed setting blacklisted attribute"
+        record = TestModel.from_attribute_data({ name: 'CASH', number: '1234'})
+        assert_nil record.number
+    end
+
+    def test_whitelisting
+        refute TestModel.new.setting_attribute_is_allowed?('updated_at',Lanes::User.current)
+        TestModel.send :whitelist_attributes, :updated_at
+        assert TestModel.new.setting_attribute_is_allowed?('updated_at',Lanes::User.current)
+    end
+
+    def test_recursive_cleaning_belongs_to
+        assert TestModel.has_exported_association?( :bt, admin )
+        data = { name: 'testing', bt: { description: 'childish', secret_field: 'dr evil' } }
+        record = TestModel.new
+        cleaned = record.set_attribute_data(data)
+        assert_equal( { name: 'testing', bt:{ description: 'childish' } }, cleaned)
+        assert record.bt
+        assert_equal 'childish', record.bt.description
+        assert_nil record.bt.secret_field
+    end
+
+    def test_recursive_cleaning_has_many
+        assert TestModel.has_exported_association?( :hm, admin )
+        data = {
+            name: 'testing',
+            hm: [
+              { description: 'childish-1', secret_field: 'dr evil' },
+              { description: 'childish-2', secret_field: 'dr evil' }
+          ]}
+        record = TestModel.new
+        cleaned_data = record.set_attribute_data(data)
+        assert_equal 2, record.hm.length
+        assert_equal cleaned_data, {:name=>"testing", :hm=>[{:description=>"childish-1"}, {:description=>"childish-2"}]}
+        assert_saves record
+    end
+
+    def test_sending_to_method
+        tm = TestModel.new
+        def tm.meaning_of_life=(var); @setting = var end
+        tm.set_attribute_data({ meaning_of_life: 42 })
+        assert_nil tm.instance_variable_get(:@setting)
+        TestModel.send :whitelist_attributes, :meaning_of_life
+        tm.set_attribute_data({ meaning_of_life: 42 })
+        assert_equal 42, tm.instance_variable_get(:@setting)
+    end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,26 @@
+require_relative 'spec_helper'
+
+describe Lanes::Configuration do
+
+    def test_changing_values_are_logged
+        begin
+            assert_logs_matching( /table_prefix changed from / ) do
+                Lanes.config.table_prefix=:foo
+            end
+        ensure
+            Lanes.silence_logs {   Lanes.config.table_prefix='' }
+        end
+    end
+
+    def test_callbacks_are_fired
+        sentinel = false
+        Lanes.config.on_change(:environment) do |nv,ov|
+            sentinel = nv
+        end
+        Lanes.silence_logs do
+            Lanes.config.environment = :testing
+            assert_equal sentinel, :testing
+        end
+    end
+
+end

data/spec/fixtures/lanes/users.yml

@@ -0,0 +1,13 @@
+admin:
+  login: admin
+  name: Administrator Jane
+  email: admin@test.com
+  password_digest: <%= BCrypt::Password.create('password') %>
+  role_names: ['administrator']
+
+support:
+  login: support
+  name: Supporter Joe
+  email: support@test.com
+  password_digest: <%= BCrypt::Password.create('password') %>
+  role_names: ['support']

data/spec/helpers/SpecHelper.js

@@ -0,0 +1,18 @@
+beforeEach(function(){
+    jasmine.addMatchers({
+        toBeDeactivated: function() {
+            return {
+                compare: function(account){
+                    var accountStatusCode = account.get('status').statusCode;
+                    var result = { pass: accountStatusCode === 5 };
+                    if(result.pass) {
+                        result.message =  "Expected account with status code '" + accountStatusCode + " NOT to be deactivated.";
+                    } else {
+                        result.message =  "Expected account with status code '" + accountStatusCode + "' to be deactivated.";
+                    }
+                    return result;
+                }
+            };
+        }
+    });
+});

data/spec/locked_fields_spec.rb

@@ -0,0 +1,27 @@
+require_relative 'spec_helper'
+
+class Customer < Lanes::Model
+    def self.attribute_names
+        [:terms_id]
+    end
+end
+
+Lanes::Access::Roles::Support.read << Customer
+Lanes::Access::Roles::Administrator.lock Customer, :terms_id
+
+class LockedFieldsTest < Lanes::TestCase
+
+    def setup
+        @user = Lanes::User.new( login: 'test', email: 'bob@test.com', name: 'Bob', password: 'testtest')
+        @purchaser = Lanes::User.new( login: 'test', email: 'bob@test.com', name: 'Bob', password: 'testtest')
+    end
+
+    def test_validations
+        @user.role_names = ['support']
+        assert_saves @user
+        assert @user.can_read?(Customer), "User with support role cannot read Customer"
+        refute @user.can_write?(Customer), "User can write, but shouldn't be able to"
+        refute @user.can_read?(Customer, :terms_id), "User can read :terms_id but shouldn't be able to"
+    end
+
+end

data/spec/numbers_spec.rb

@@ -0,0 +1,26 @@
+require_relative 'spec_helper'
+
+describe Lanes::Numbers do
+
+    Num = Lanes::Numbers
+
+
+    def test_percnum
+        assert Num::PercNum.new( '5%'  ).is_percentage?, "is a percentage"
+        assert Num::PercNum.new( '5% ' ).is_percentage?, "is a percentage"
+        assert Num::PercNum.new( '5.3 % ' ).is_percentage?, "is a percentage"
+        refute Num::PercNum.new( '$5.3 ' ).is_percentage?, "is not a percentage"
+        # this is debatable, but we have to draw the line somewhere
+        refute Num::PercNum.new( '%5.3 ' ).is_percentage?, "is a percentage"
+
+        assert_equal '95.0',  Num::PercNum.new( '5'  ).debit_from(100).to_s
+        assert_equal '95.0',  Num::PercNum.new( '5%' ).debit_from(100).to_s
+        assert_equal '105.0', Num::PercNum.new( '5%' ).credit_to(100).to_s
+        assert_equal '95.0',  Num::PercNum.new( '-5%').credit_to(100).to_s
+
+        assert_equal '137.38449', Num::PercNum.new( '33.383%' ).credit_to(103).to_s
+        assert_equal '68.61551',  Num::PercNum.new( '33.383%' ).debit_from(103).to_s
+    end
+
+
+end

data/spec/role_collection_spec.rb

@@ -0,0 +1,19 @@
+require_relative 'spec_helper'
+
+
+
+class AccessTester < Lanes::Model
+    def self.attribute_names
+        [:name]
+    end
+end
+
+
+class RoleCollectionTest < Lanes::TestCase
+
+    def test_administrator_grants
+        user = lanes_users(:admin)
+        assert_includes user.role_names, 'administrator'
+        assert user.roles.can_read?(AccessTester)
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,163 @@
+require 'minitest/autorun'
+require 'mocha/mini_test'
+require 'rack/test'
+require 'lanes'
+require 'lanes/api'
+require 'hashie/mash'
+require 'active_record'
+require 'active_record/fixtures'
+require 'minitest/around/unit'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'pry'
+
+require_relative 'testing_models'
+
+RAILS_ENV = "test"
+I18n.enforce_available_locales = true
+Lanes::DB.establish_connection('test')
+Lanes.logger=Logger.new( File.open('log/test.log', File::WRONLY | File::APPEND | File::CREAT ))
+ActiveRecord::Base.logger = Lanes.logger
+ActiveSupport::Dependencies.mechanism = :require
+
+module Lanes
+
+    class TestCase < ActiveSupport::TestCase
+        include Lanes
+        include ActiveRecordMocks::IncludeMe
+
+        include ActiveRecord::TestFixtures
+        self.fixture_path =  Pathname.new(__FILE__).dirname.join('fixtures')
+        setup do
+            Thread.current[:lanes_current_user] = lanes_users(:admin)
+            Lanes::Access.calculate_model_access!
+        end
+
+        self.use_transactional_fixtures = true
+        fixtures :all
+
+        def admin
+            lanes_users(:admin)
+        end
+
+        extend MiniTest::Spec::DSL
+        register_spec_type self do |desc|
+            desc < Lanes::Model if desc.is_a? Class
+        end
+
+    end
+
+    class ApiTestCase < TestCase
+        include Rack::Test::Methods
+
+        teardown do
+            @current_user = nil
+        end
+
+        def app
+            Lanes::API::Root.new
+        end
+
+        def json_body
+            Hashie::Mash.new Oj.load( last_response.body )
+        end
+
+        def json_data
+            json_body['data']
+        end
+
+        [ :get, :put, :post, :delete, :patch].each do |name|
+            define_method(name) do |uri, params = {}, env = {}, &block|
+                session = env['rack.session'] ||= {}
+                env[Rack::Csrf.rackified_header] = Rack::Csrf.token(env)
+                session[:user_id] = @current_user.id if @current_user
+                params = Oj.dump(params, mode: :compat) if params.is_a?(Hash)
+                super(uri,params,env,&block)
+            end
+        end
+
+        def login!(user=admin)
+            @current_user = user
+        end
+
+        def assert_ok
+            assert last_response.ok?, "Request failed with #{last_response.status}"
+        end
+        def refute_ok
+            refute last_response.ok?, "Request succeeded with status #{last_response.status}, expected non-2XX"
+        end
+    end
+end
+
+module MiniTest
+    module Assertions
+
+        def assert_logs_matching( regex, failure_message=nil, &block )
+            old_logger = Lanes.logger
+            begin
+                output = ""
+                Lanes.logger=Logger.new( StringIO.new(output) )
+                yield
+                assert_match( regex, output, failure_message )
+            ensure
+                Lanes.logger=old_logger
+            end
+        end
+
+
+        def assert_saves( model )
+            assert model.save, "#{model.class} failed to save: #{model.errors.full_messages.join(',')}"
+        end
+        def refute_saves( model, *errors )
+            refute model.save, "#{model.class} saved successfully when it should not have"
+            errors.each do |error|
+                if model.errors[error.to_sym].empty?
+                    raise MiniTest::Assertion, "expected #{model.class} to have an error on #{error}"
+                end
+            end
+
+        end
+
+
+        def assert_event_fires( klass, event, &block )
+            @event_results = []
+            klass.observe(event) do | *args |
+                @event_results = args
+            end
+            yield
+            raise MiniTest::Assertion, "Event #{event} was not fired" if @event_results.empty?
+        end
+
+        def last_event_results
+            @event_results
+        end
+    end
+end
+
+
+module FixtureHelpers
+
+    extend ActiveSupport::Concern
+
+    included do
+        alias_method_chain :table_rows, :custom_autoset_fields
+    end
+
+    def table_rows_with_custom_autoset_fields
+        results = table_rows_without_custom_autoset_fields
+        if model_class
+            results[ table_name ].each do | row |
+                row['visible_id'] = Lanes::SequentialId.next_for( model_class ) if model_class.column_names.include?('visible_id')
+                row['hash_code' ] = Lanes::Strings.random if model_class.column_names.include?('hash_code')
+                row['created_at'] = Time.now if model_class.column_names.include?('created_at')
+                row['updated_at'] = Time.now if model_class.column_names.include?('updated_at')
+                # 135138680 == "admin"
+                row['created_by_id'] = 135138680  if model_class.column_names.include?('created_by_id')
+                row['updated_by_id'] = 135138680 if model_class.column_names.include?('updated_by_id')
+            end
+        end
+        results
+    end
+end
+
+ActiveRecord::FixtureSet.send :include, FixtureHelpers

data/spec/strings_spec.rb

@@ -0,0 +1,41 @@
+require_relative 'spec_helper'
+
+describe Lanes::Strings do
+
+    # just 'cuz
+    Str = Lanes::Strings
+
+    def test_random_is_of_proper_length
+        assert_equal 12, Str.random.length
+        assert_equal 6, Str.random(6).length
+    end
+
+    def test_random_doesnt_use_bad_chars
+        bad = Str::BAD_RAND_CHARS
+        assert bad.present?, 'list of bad random chars is empty'
+        0.upto(10).each do | i |
+            string = Str.random
+            string.each_char do |c|
+                refute bad.include?(c), "Random string #{string} included bad char '#{c}'"
+            end
+        end
+    end
+
+    def test_code_identifier_shortens
+        # if all words are long engouth to shorten, then it takes an
+        # equal number from each
+        assert_equal 'GENACMCORP', Str.code_identifier( 'General Acme Corp' )
+        # If one word is too short, it'll attempt to make up the difference with
+        # later words
+        assert_equal 'GENIINCORP', Str.code_identifier( 'General I Incorporated' )
+        # If it gets to the end and it's still too short, it'll append the
+        # padding char
+        assert_equal 'GENERALIBC', Str.code_identifier( 'General I BC' )
+        assert_equal 'GENERALIB*', Str.code_identifier( 'General I B.', padding: '*' )
+        assert_equal 'FSANSEYEAG', Str.code_identifier( 'Four score and seven years ago', padding: '*' )
+        assert_equal 'ALONSBEAST', Str.code_identifier( 'A long s beasty' )
+        assert_equal 'GE', Str.code_identifier( 'GE', padding: false )
+        assert_equal 'HI33ME', Str.code_identifier( 'Hi 33 Me!', padding: false )
+        assert_equal 'BADIANDOCO', Str.code_identifier( "Bayer, Dickinson and O'Conner", padding: false )
+    end
+end

data/spec/testing_models.rb

@@ -0,0 +1,54 @@
+require "active_record_mocks"
+
+module TestingModels
+
+
+    def around(&block)
+        with_testing_models(&block)
+    end
+
+    def with_testing_models
+        with_mocked_tables do |m|
+
+            m.enable_extension "hstore"
+
+            m.create_table do |t|
+                t.model_name :TestModel
+                t.parent_class "Lanes::Model"
+                t.belongs_to :bt, class_name: 'Tmbt'
+                t.has_many   :hm, class_name: 'Tmhm'
+                t.layout do |l|
+                    l.integer :bt_id
+                    l.string :name, :number
+                end
+            end
+            TestModel.export_associations( :bt, :hm, writable: true )
+
+            m.create_table do |t|
+                t.model_name :Tmbt
+                t.parent_class "Lanes::Model"
+                t.layout do |l|
+                    l.string :description, :secret_field, :notes
+                end
+            end
+
+            m.create_table do |t|
+                t.model_name :Tmhm
+                t.parent_class "Lanes::Model"
+                t.layout do |l|
+                    l.integer :test_model_id
+                    l.string :description, :secret_field, :notes
+                end
+            end
+            Tmhm.blacklist_attributes :secret_field
+
+            Lanes::Access.calculate_model_access!
+            yield
+
+            TestModel.blacklisted_attributes.clear if TestModel.blacklisted_attributes
+
+        end
+    end
+
+
+end

data/spec/user_role_spec.rb

@@ -0,0 +1,7 @@
+require_relative 'spec_helper'
+
+
+class UserRoleTest < Lanes::TestCase
+
+
+end

data/spec/user_spec.rb

@@ -0,0 +1,53 @@
+require_relative 'spec_helper'
+
+describe Lanes::User do
+
+    before do
+        @user = Lanes::User.new( login: 'test', email: 'bob@test.com', name: 'Bob', password: 'testtest')
+    end
+
+    it "validates attributes" do
+        user = Lanes::User.new
+        refute_saves user, 'login'
+        user.assign_attributes login: 'test', email: 'bob', name: 'Bob'
+        refute_saves user, 'email'
+        user.email = 'bob@test.com'
+        refute_saves user, 'password'
+        user.password = 'password'
+        assert_saves user
+    end
+
+    it "sets roles" do
+        @user.role_names = ['administrator']
+        assert_saves @user
+        assert_equal [ 'administrator' ], @user.role_names
+    end
+
+    it "can has built-in roles" do
+        @support = Lanes::User.new( login: 'test', email: 'support@test.com', name: 'support Bob',
+          password: 'testtest', role_names:['support'])
+        @admin = Lanes::User.new( login: 'test', email: 'admin@test.com', name: 'admin Bob',
+          password: 'testtest', role_names:['administrator'])
+
+        assert @admin.can_read?(@support)
+        assert @admin.can_write?(@support)
+
+        assert @support.can_read?(@admin)
+        refute @support.can_write?(@admin)
+    end
+
+    it "can be set from attribute data" do
+        attrs = { login: 'test', email: 'bob', name: 'Bob', password:'password' }
+        assert_equal attrs, @user.set_attribute_data( attrs, lanes_users(:admin) )
+    end
+
+    it "users can update themselves" do
+        user  = lanes_users(:support)
+        admin = lanes_users(:admin)
+        attrs = { id: 34, login: 'test', email: 'bob', name: 'Bob', password:'password' }
+        assert_empty admin.set_attribute_data( attrs, user )
+        attrs[:id] = user.id
+        assert_equal( {email: 'bob', name: 'Bob', password:'password'}, user.set_attribute_data(attrs, user) )
+    end
+
+end

data/tasks/migrations.rake

@@ -0,0 +1,22 @@
+require 'lanes'
+require 'active_support/core_ext/string/strip'
+require 'fileutils'
+## quite a bit of this is cribbed from Sinatra ActiveRecord
+
+load 'active_record/railties/databases.rake'
+require 'rake'
+
+
+namespace :db do
+
+    task :environment do
+        Lanes::DB.configure_rake_environment
+    end
+
+    desc "create an ActiveRecord migration"
+    task :create_migration,[ :name ] do | t, args |
+        Lanes::DB.create_migration( "create_skr_" + args[:name] )
+    end
+
+
+end

data/tasks/publish.rake

@@ -0,0 +1,8 @@
+namespace :publish do
+
+    desc "generate and publish docs to stockor.org"
+    task :docs => 'doc' do
+        system( "rsync", "doc/", "-avz", "--delete", "stockor@stockor.org:~/docs/core")
+    end
+
+end

data/views/index.erb

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, minimal-ui"/>
+        <title><%= Lanes.config.app_title %></title>
+
+        <%=  javascript_tag 'lanes-workspace.js' %>
+        <%=  stylesheet_tag 'lanes-workspace' %>
+
+
+        <script type="text/javascript">
+         Lanes.Workspace.create('.lanes-test-root', {
+           csrf_token: "<%= csrf_token %>",
+           view: 'Lanes.Workspace.Layout',
+           user_data:  <%= user_data %>,
+           root_path: "<%= lanes_api_url %>"
+         }, <%= bootstrap_data %> );
+        </script>
+    </head>
+
+    <body style="margin: 0; background-color: white;">
+
+        <div class="lanes-test-root">
+        </div>
+
+    </body>
+</html>