hippo-fw 0.9.1

data/spec/server/assertions.rb

@@ -0,0 +1,11 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :execute_successfully do
+    match do |cmd|
+        @cmd_last_output = `#{cmd} 2>&1`
+         $?.exitstatus == 0
+    end
+    description do
+        "Command exited with #{$?.exitstatus}.  Output was: #{@cmd_last_output}"
+    end
+end

data/spec/server/asset_spec.rb

@@ -0,0 +1,42 @@
+require_relative "spec_helper"
+
+describe Hippo::Asset do
+
+    include TestingModels
+
+    around(:each) do |example|
+        with_testing_models do
+            TestModel.has_one :asset, as: :owner, :class_name=>'Hippo::Asset'
+            example.run
+        end
+    end
+
+    it 'saves image' do
+        tm = TestModel.new
+        @model = TestModel.new
+        asset = @model.build_asset
+        tf=Tempfile.new
+        tf.write fixtures_path.join('logo.png').read
+        tf.rewind
+        asset.file = {
+            type: "image/png", name: "file",
+            filename: "Screen Shot 2016-10-28 at 5.15.37 PM.png",
+            head: "Content-Disposition: form-data; name=\"file\"; filename=\"Screen Shot 2016-10-28 at 5.15.37 PM.png\"\r\nContent-Type: image/png\r\n",
+            tempfile: tf
+        }
+
+        expect(@model.save).to eq(true)
+
+        expect(@model.asset.file_data.keys).to eq(["original", "medium", "thumbnail"])
+        expect(
+            @model.asset.file_data['original']['metadata'].without('filename')
+        ).to eq({
+                "size"=>42228,
+                "mime_type"=>"image/png",
+                "width"=>500,
+                "height"=>223
+                })
+
+    end
+
+end

data/spec/server/command_spec.rb

@@ -0,0 +1,73 @@
+require_relative "spec_helper"
+require_relative "./assertions"
+require "hippo/cli"
+require "diffy"
+require "find"
+
+describe Hippo::Command do
+    let(:app_name)  { "appy-app" }
+    let(:hippo)     { Pathname.new(__FILE__).dirname.join('..','..','bin','hippo') }
+    let(:generated_path) { Pathname.pwd }
+    let(:reference_path) { Pathname(__FILE__).dirname.join("..","..", "command-reference-files") }
+
+    around(:each) do | t |
+        Dir.mktmpdir do |dir|
+            @dir = dir
+            Dir.chdir(dir) do
+                RSpec::Mocks.with_temporary_scope do
+                    allow_any_instance_of(Knitter::Yarn).to receive(:init).and_return(true)
+                    allow_any_instance_of(Knitter::Yarn).to receive(:add).and_return(true)
+                    expect("#{hippo} new #{app_name} --no-packages").to execute_successfully
+                    Dir.chdir(app_name) do
+                        t.call
+                    end
+                end
+            end
+        end
+    end
+
+    def compare_generated(reference)
+        reference.find.each do | path |
+            relative = path.relative_path_from(reference)
+            generated = generated_path.join(relative)
+            expect(generated).to exist, "File was not created: #{relative}"
+
+            next unless path.file?
+            diff = Diffy::Diff.new(path.to_s, generated.to_s, source: 'files', context: 1)
+            # if !diff.to_s.empty? # update
+            #     path.write(generated.read)
+            # end
+            expect(diff.to_s).to be_empty, "DIFF:\n#{diff.to_s}"
+        end
+    end
+
+    it "generates an application" do
+        reference = reference_path.join('initial')
+        gemfile = reference.join("Gemfile")
+        gemfile.write gemfile.read.gsub(/gem \"hippo\", \'\d+\.\d+\.\d+\'/, "gem \"hippo\", '#{Hippo::VERSION}'")
+
+        compare_generated(reference)
+        generated_path.find.each do | path |
+            relative = path.relative_path_from(generated_path)
+            reference_copy = reference.join(relative)
+            expect(reference_copy).to exist, "Created file that should not exist: #{relative}"
+        end
+    end
+
+    it "generates a screen" do
+        expect("#{hippo} gen screen ready-set-go").to execute_successfully
+        compare_generated(reference_path.join('screen'))
+    end
+
+    it "generates a model" do
+        ENV['MIGRATION_TIMESTAMP']='20150218032025'
+        expect("#{hippo} gen model test-test name:string email:string").to execute_successfully
+        compare_generated(reference_path.join('model'))
+    end
+
+    it "generates a component" do
+        expect("#{hippo} gen component big").to execute_successfully
+        compare_generated(reference_path.join('component'))
+    end
+
+end

data/spec/server/concerns/api_path_spec.rb

@@ -0,0 +1,20 @@
+require_relative "../spec_helper"
+
+describe "ApiPath" do
+
+    include TestingModels
+
+    around do |example|
+        with_testing_models do
+            example.run
+        end
+    end
+
+    it "generates path" do
+        expect('test-models').to eq(TestModel.api_path)
+    end
+
+    it "converts path to model" do
+        expect(TestModel).to eq(Hippo::Model.from_api_path('test-models'))
+    end
+end

data/spec/server/concerns/association_extensions_spec.rb

@@ -0,0 +1,24 @@
+require_relative "../spec_helper"
+
+describe "AssociationExtensions" do
+
+    include TestingModels
+
+    around(:each) do |example|
+        with_testing_models do
+            example.run
+        end
+    end
+
+    it "adds event listener that requires inverse" do
+        expect {
+            TestModel.has_one(:tmhm, :listen=>{:save=>:on_save})
+        }.to raise_error(ArgumentError, /the association does not have an inverse_of/)
+    end
+
+    it "does not allow other garbage" do
+        expect {
+            TestModel.has_one(:tmhm,:blarg=>true)
+        }.to raise_error(ArgumentError, /Unknown key/)
+    end
+end

data/spec/server/concerns/attr_accessor_with_default_spec.rb

@@ -0,0 +1,63 @@
+require "hippo/spec_helper"
+
+describe "Attr Accessor With Default" do
+
+    Shared = Struct.new(:value)
+
+    class AttrTestClass
+        include Hippo::Concerns::AttrAccessorWithDefault
+        attr_accessor_with_default :as_proc, Proc.new{ 42 }
+        attr_accessor_with_default :non_copying, ->{ "default string" }
+        attr_accessor_with_default :shared, Shared.new('default')
+        attr_accessor_with_default :non_shared, ->{ Shared.new('default') }
+        attr_accessor_with_default :startingnil
+    end
+
+    class Inherited<AttrTestClass
+        non_shared "Foo"
+    end
+
+    it "sets up access" do
+        a = AttrTestClass.new
+        b = AttrTestClass.new
+
+        expect(b.as_proc).to be(42)
+
+        expect(b.non_copying).to eq("default string")
+
+        b.non_copying = "A new string"
+
+        expect(a.non_copying).to eq("default string")
+        a.non_copying = "third value"
+        expect(b.non_copying).to eq("A new string")
+
+        expect(a.shared.value).to eq("default")
+        expect(b.shared.value).to eq("default")
+
+        a.shared.value = "a new value"
+
+        expect(a.shared.value).to eq("a new value")
+        expect(b.shared.value).to eq("a new value")
+
+        a.non_shared.value = "a new value"
+        expect(a.non_shared.value).to eq("a new value")
+        expect(b.non_shared.value).to eq("default")
+    end
+
+    def test_inheritance
+        a = Inherited.new
+        b = AttrTestClass.new
+        expect(a.non_shared).to be_a(String)
+        expect(b.non_shared).to be_a(String)
+        expect(a.non_shared.value).to eq("Foo")
+        expect(b.non_shared.value).to eq("default")
+    end
+
+    def test_nils
+        a = AttrTestClass.new
+        expect( a.startingnil ).to be_nil
+        a.startingnil = 22
+        expect(aa.startingnil).to eq(22)
+    end
+
+end

data/spec/server/concerns/export_methods_spec.rb

@@ -0,0 +1,34 @@
+require_relative "../spec_helper"
+
+describe "Exporting Methods" do
+    include TestingModels
+
+    around(:each) do |example|
+        with_testing_models do
+            example.run
+        end
+    end
+
+    it 'can use simple delegation' do
+
+        expect(TestModel.new).to_not respond_to(:bt_description)
+
+        TestModel.send :delegate_and_export, "bt_description"
+
+        md = TestModel.new
+        expect(md).to respond_to(:bt_description)
+        expect(md.bt_description).to be_nil
+        md.build_bt( description: "test123")
+        expect(md.bt_description).to eq("test123")
+
+        expect(TestModel.has_exported_method?( :bt_description, nil )).to be(true)
+    end
+
+    def test_dependancy_calculation
+        TestModel.send :delegate_and_export, "bt_description"
+        TestModel.send :delegate_and_export, "bt_notes", optional: false
+        expect(TestModel.exported_method_dependancies([])).to include(:bt)
+        expect(TestModel.exported_method_dependancies(['bt_description'])).to include(:bt)
+    end
+
+end

data/spec/server/concerns/export_scope_spec.rb

@@ -0,0 +1,14 @@
+require_relative "../spec_helper"
+
+describe "Export Scopes" do
+    include TestingModels
+
+    def test_scope_method_creation
+        refute TestModel.respond_to?(:big_query)
+        TestModel.send( :scope, :big_query, ->{},  {export: true}  )
+        assert TestModel.respond_to?(:big_query)
+        assert TestModel.has_exported_scope?(:big_query,DummyUser.new)
+    end
+
+
+end

data/spec/server/concerns/exported_limits_spec.rb

@@ -0,0 +1,51 @@
+require_relative "../spec_helper"
+
+describe "Exporting Limits" do
+    module FakeScope
+        extend ActiveSupport::Concern
+        class_methods do
+            def scope(*args) # act like ActiveRecord model
+            end
+        end
+    end
+
+    class Base
+        include FakeScope
+        include Hippo::Concerns::ExportScope
+        include Hippo::Concerns::ExportMethods
+    end
+
+    class LimitsTestingModel < Base
+
+        def secret_method( name, query )
+        end
+
+        def test_method( name, query )
+        end
+
+        export_methods :test_method, limit: lambda{ | user, type, name |
+            user == 'anon'
+        }
+
+        scope :admin_data, lambda { | param |
+            param
+        }, export: {limit: :only_admins}
+
+        export_methods :secret_method, limit: :only_admins
+
+
+        def self.only_admins( user, type, name )
+            return user == 'admin'
+        end
+
+    end
+
+    def test_limits
+       assert LimitsTestingModel.has_exported_method?( 'test_method', 'anon' ), "anyone can retrieve no_limit data"
+        assert LimitsTestingModel.has_exported_scope?( 'admin_data', 'admin' ), "Admins can retrieve admin data"
+        refute LimitsTestingModel.has_exported_scope?( 'admin_data', 'non-admin' ), "Non-Admin cannot retrieve admin data"
+        assert LimitsTestingModel.has_exported_method?( 'secret_method', 'admin' ), "Public can retrieve public data"
+        refute LimitsTestingModel.has_exported_method?( 'secret_method', 'unk' ), "User must be admin to retrieve public data"
+    end
+
+end

data/spec/server/concerns/pub_sub_spec.rb

@@ -0,0 +1,132 @@
+require_relative "../spec_helper"
+
+describe "PubSub" do
+
+    include TestingModels
+    around(:each) do |example|
+        with_testing_models do
+            example.run
+        end
+    end
+
+
+
+    #         class A < Hippo::Model
+    #             has_additional_events :test_one
+    #             def on_save_b(*args)
+    #             end
+    #             def on_save_event_tester(*args)
+    #             end
+    #         end
+    #         m.create_table do |t|
+    #             t.model_name :A
+    #             t.parent_class "Hippo::Model"
+    #             t.belongs_to :b_model, class_name: "B", listen: { save: :on_save_b },
+    #                          inverse_of: :a_model
+
+    #             t.belongs_to :event_tester, class_name: "EventTester", inverse_of: :a_models,
+    #                          listen: { save: 'on_save_event_tester' }
+
+    #             t.layout do |l|
+    #                 l.integer :b_model_id, :b_id
+    #                 l.integer :event_tester_id
+    #             end
+    #         end
+
+    #         class B < Hippo::Model
+    #             def on_save_a(*args)
+    #             end
+    #         end
+    #         table = m.create_table do |t|
+    #             t.model_name :B
+    #             t.parent_class "Hippo::Model"
+    #             t.has_one :a_model, class_name: "A", listen: { save: 'on_save_a' },
+    #                          inverse_of: :b_model
+    #             t.layout do | l |
+    #                 l.string :mumble
+    #             end
+    #         end
+
+    #         class EventTester < Hippo::Model
+    #         end
+
+    #         m.create_table do |t|
+    #             t.model_name :EventTester
+    #             t.parent_class "Hippo::Model"
+    #             t.has_many   :a_models, class_name: 'A', inverse_of: :event_tester
+
+    #             t.layout do |l|
+    #                 l.string :name, :number
+    #             end
+    #         end
+    #         test.call
+    #     end
+    # end
+
+    # it "listens to other associations" do
+    #     a=A.new
+    #     b=a.build_b_model
+    #     assert b.a_model
+    #     a.expects(:on_save_b)
+    #     assert a.save
+
+    #     et = EventTester.new
+    #     a=et.a_models.build
+    #     a.expects(:on_save_event_tester)
+    #     et.save
+    # end
+
+    # it "registers" do
+    #     assert_equal [ :save, :create, :update, :destroy ],
+    #                  EventTester.valid_event_names
+    #     assert_equal [ :save, :create, :update, :destroy, :test_one ],
+    #                  A.valid_event_names
+    # end
+
+    # it "can only observe valid events" do
+    #     assert_raises(EventTester::InvalidEvent) do
+    #         EventTester.observe(:invalid_event) do | ev |
+    #         end
+    #     end
+    #     assert_raises(EventTester::InvalidEvent) do
+    #         B.observe(:test_two) do | ev |
+    #         end
+    #     end
+    #     assert_raises(EventTester::InvalidEvent) do
+    #         A.observe(:glub_glub) do | ev |
+    #         end
+    #     end
+    #     begin
+    #         B.observe(:test_one) do | ev |
+    #         end
+    #     rescue EventTester::InvalidEvent=>e
+    #         assert_equal 'test_one is not a valid event for B', e.to_s
+    #     end
+    # end
+
+    # it "events can be subscribed to" do
+    #     EventTester.observe(:save) do | ev |
+    #     end
+    # end
+
+    # it "can be fired and observed" do
+    #     results=[]
+    #     A.observe(:test_one) do | one, two |
+    #         results = [ one, two ]
+    #     end
+    #     a=A.new
+    #     a.send(:fire_pubsub_event, :test_one, 3, 5 )
+    #     assert_equal [3, 5], results
+
+    #     a.send(:fire_pubsub_event, :test_one, 'foo' )
+    #     assert_equal ['foo', nil], results
+    # end
+
+    # it "can use custom event assertions" do
+    #     assert_event_fires(A, :test_one) do
+    #         A.new.send(:fire_pubsub_event, :test_one, 3, 5)
+    #     end
+    #     assert_equal [ 3, 5 ], last_event_results
+    # end
+
+end