fron 0.1.0 → 0.1.1

data/spec/core/adapter/rails_spec.rb

@@ -0,0 +1,72 @@
+require 'fron/core'
+require 'fron/storage'
+
+describe Fron::Adapters::RailsAdapter do
+
+  subject do
+    described_class.new({
+      fields: [:name],
+      endpoint: "test",
+      resources: "users",
+      resource: "user"
+    })
+  end
+
+  let(:proc) { Proc.new {} }
+  let(:request) { double :request }
+
+  before do
+    subject.instance_variable_set "@request", request
+  end
+
+  describe "#all" do
+    it "should call GET request to resources url" do
+      request.should receive(:url=).with "test/users.json"
+      request.should receive(:get) do |&block|
+        block.call double json: true
+      end
+      proc.should receive(:call)
+      subject.all &proc
+    end
+  end
+
+  describe "#get" do
+    it "should call GET request to resource url" do
+      request.should receive(:url=).with "test/users/0"
+      request.should receive(:get) do |&block|
+        block.call double json: true
+      end
+      proc.should receive(:call)
+      subject.get '0', &proc
+    end
+  end
+
+  describe "#set" do
+    it "should call POST request for new record" do
+      request.should receive(:url=).with "test/users.json"
+      request.should receive(:post) do |&block|
+        block.call double status: 201
+      end
+      proc.should receive(:call)
+      subject.set nil, {}, &proc
+    end
+
+    it "should call PUT request for exsistsing record" do
+      request.should receive(:url=).with "test/users/0"
+      request.should receive(:put) do |&block|
+        block.call double status: 201
+      end
+      proc.should receive(:call)
+      subject.set 0, {}, &proc
+    end
+
+    it "should call block with error" do
+      request.should receive(:url=).with "test/users/0"
+      request.should receive(:put) do |&block|
+        block.call double status: 422, json: 'error'
+      end
+      proc.should receive(:call).with 'error'
+      subject.set 0, {}, &proc
+    end
+  end
+end

data/spec/core/application_spec.rb

@@ -0,0 +1,35 @@
+require 'fron/core'
+
+class TestApplication < Fron::Application
+  config.title = 'Test Application'
+  config.logger.level = :error
+end
+
+describe Fron::Application do
+
+  subject { TestApplication.new }
+
+  after do
+    subject.config.app.remove!
+  end
+
+  describe "#initialize" do
+    it 'should insert the application into the DOM' do
+      subject.config.app.parent.should_not be nil
+    end
+
+    it 'should set the title of the document' do
+      DOM::Document.title.should eq 'Test Application'
+    end
+  end
+
+  describe "#loadExternalStylesheets" do
+    it 'should load external stylesheets' do
+      subject.config.stylesheets = ['test']
+      subject.send(:loadExternalStylesheets)
+      link = DOM::Document.head.find('link')
+      link['href'].should be 'test'
+      link.remove!
+    end
+  end
+end

data/spec/core/component_spec.rb

@@ -0,0 +1,107 @@
+require 'fron/core'
+
+class TestComponent < Fron::Component
+  attr_reader :rendered
+
+  def render
+    @rendered = true
+  end
+end
+
+describe Fron::Component do
+
+  subject  { TestComponent.new }
+  let(:listeners) { subject.instance_variable_get("@listeners") }
+
+  describe "DSL" do
+
+    subject { TestComponent }
+
+    describe "#tag" do
+      it 'should set the tagname' do
+        subject.tag 'td'
+        subject.tagname.should eq 'td'
+      end
+    end
+
+    describe "#on" do
+      it 'should create events array' do
+        subject.on :click, :test
+        subject.events.should_not be nil
+      end
+
+      it 'should push event into the events array' do
+        subject.on :click, :test
+        subject.events.length.should be 2
+      end
+    end
+
+    describe '#component' do
+      it 'should create components array' do
+        subject.component :test, 'test'
+        subject.components.should_not be nil
+        subject.components.length.should be 1
+      end
+
+      it 'should create attr_reader for component' do
+        subject.component :a, 'a'
+        subject.instance_methods.include?(:a).should be true
+      end
+    end
+
+    describe '#delegate' do
+      it 'should create delegated methods' do
+        subject.delegate :text, :test
+        subject.instance_methods.include?(:text).should be true
+        subject.instance_methods.include?(:text=).should be true
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it 'should create element' do
+      subject.tag.should eq 'td'
+    end
+
+    it 'should apply events' do
+      listeners[:click].length.should eq 2
+    end
+
+    it 'should create components' do
+      subject.a.should_not be nil
+      subject.a.tag.should eq 'a'
+
+      subject.test.should_not be nil
+      subject.test.tag.should be 'test'
+    end
+
+    it 'should call render if model given' do
+      comp = TestComponent.new(Fron::Model.new)
+      comp.rendered.should be true
+    end
+  end
+
+  describe "#component" do
+    it 'should create a component from a Class' do
+      subject.component 'b', TestComponent
+      subject.instance_variable_get("@b").class.should eq TestComponent
+    end
+
+    it 'should create a component from a String' do
+      subject.component 'e', 'i'
+      subject.instance_variable_get("@e").class.should eq Fron::Component
+    end
+
+    it 'should append component' do
+      subject.component 'd', TestComponent
+      comp = subject.instance_variable_get("@d")
+      comp.parent.should eq subject
+    end
+
+    it 'should call block if block given' do
+      called = false
+      subject.component('c', 'x') { called = true }
+      called.should be true
+    end
+  end
+end

data/spec/core/configuration_spec.rb

@@ -0,0 +1,20 @@
+require 'fron'
+
+describe Fron::Configuration do
+
+  subject { described_class.new }
+
+  describe '#initialize' do
+    it 'should create a logger' do
+      subject.logger.class.should be Fron::Logger
+    end
+
+    it 'should create the application container' do
+      subject.app.class.should be Fron::Configuration::App
+    end
+
+    it 'should create the yield container' do
+      subject.main.class.should be Fron::Configuration::Yield
+    end
+  end
+end

data/spec/core/controlller_spec.rb

@@ -0,0 +1,68 @@
+require 'fron/core'
+
+class TestController < Fron::Controller
+end
+
+describe TestController do
+
+  subject { described_class.new }
+
+  describe 'DSL' do
+
+    subject { TestController }
+
+    describe '#base' do
+      it 'should set the baseComponent' do
+        subject.base Fron::Component
+        subject.baseComponent.should eq Fron::Component
+      end
+    end
+
+    describe '#route' do
+      it 'should set routes map' do
+        allow(Fron::Router).to receive(:map)
+        subject.route '/', :test
+        subject.routes.should_not be nil
+        subject.routes.length.should eq 1
+      end
+
+      it 'should call Router.map' do
+        expect(Fron::Router).to receive(:map).once
+        subject.route '/a', :a
+      end
+    end
+
+    describe '#on' do
+      it 'should set events array' do
+        subject.on :event, :action
+        subject.events.should_not be nil
+        subject.events[0].should eq({name: :event, action: :action})
+      end
+    end
+
+    describe '#before' do
+      it 'should set before filters' do
+        subject.before :method, :action
+        subject.beforeFilters.should_not be nil
+        subject.beforeFilters[0].should eq({method: :method, actions: :action})
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it 'should create Element if no component is specified' do
+      TestController.base nil
+      subject.base.class.should eq DOM::Element
+    end
+
+    it 'should create component if component is specified' do
+      TestController.base Fron::Component
+      subject.base.class.should eq Fron::Component
+    end
+
+    it 'should call Eventable.on for event' do
+      expect(Fron::Eventable).to receive(:on).once.with 'event'
+      subject
+    end
+  end
+end

data/spec/core/eventable_spec.rb

@@ -0,0 +1,74 @@
+require 'fron/core'
+
+class TestEventable
+  include Fron::Eventable
+end
+
+describe Fron::Eventable do
+
+  subject { described_class }
+  let(:events) { subject.instance_variable_get("@events") }
+  let(:instance) { TestEventable.new }
+
+  describe "#on" do
+    it "should add to events array" do
+      subject.on 'event' do end
+      events.should_not be nil
+      events[:event].should_not be nil
+    end
+
+    it "should add block to events array" do
+      a = Proc.new {}
+      subject.on 'event', &a
+      events[:event].last.should eq a
+    end
+  end
+
+  describe "#trigger" do
+    it "should not trigger global event if called on self" do
+      expect(subject).to receive(:trigger).once.and_call_original
+      subject.trigger 'test'
+    end
+
+    it "should trigger global event if specified and not self" do
+      expect(subject).to receive(:trigger).once.and_call_original
+      instance.on 'test' do end
+      instance.trigger 'test'
+    end
+
+    it "should not trigger global event if not specified" do
+      expect(subject).not_to receive(:trigger)
+      instance.trigger 'test', false
+    end
+
+    it "should call listeners" do
+      a = Proc.new {}
+      expect(a).to receive(:call)
+      instance.on 'test', &a
+      instance.trigger 'test'
+    end
+  end
+
+  describe "#off" do
+    it "should remove the block from the events array" do
+      block = subject.on 'test' do end
+      events['test'].last.should eq block
+      subject.off 'test', block
+      events['test'].last.should_not eq block
+    end
+
+    it 'should remove all corressponding events' do
+      subject.on 'test' do end
+      events['test'].length.should_not be 0
+      subject.off 'test'
+      events['test'].length.should be 0
+    end
+
+    it 'should remove all events' do
+      subject.on 'test' do end
+      events.keys.length.should eq 2
+      subject.off
+      events.keys.length.should eq 0
+    end
+  end
+end

data/spec/core/logger_spec.rb

@@ -0,0 +1,28 @@
+require 'fron/core'
+
+describe Fron::Logger do
+
+  subject { described_class.new }
+
+  before do
+    allow(subject).to receive(:puts)
+  end
+
+  describe "#initialize" do
+    it 'should set log level to :info' do
+      subject.level.should eq :info
+    end
+  end
+
+  describe "#info" do
+    it "should add timestamp to message" do
+      expect(Time).to receive(:now).and_call_original
+      subject.info 'test'
+    end
+
+    it "should call puts" do
+      expect(subject).to receive(:puts).once
+      subject.info 'test'
+    end
+  end
+end

data/spec/core/model_spec.rb

@@ -0,0 +1,125 @@
+require 'fron/core'
+
+class TestModel < Fron::Model
+end
+
+class MockAdapter
+  def all(&block)
+    block.call [{},{}]
+  end
+
+  def get(&block)
+    block.call({name: 'User'})
+  end
+
+  def set(id,&block)
+    if id == 0
+      block.call
+    else
+      block.call({errors: true})
+    end
+  end
+end
+
+describe TestModel do
+
+  subject { described_class }
+
+  describe "DSL" do
+    describe "#adapter" do
+      it "should set adapter" do
+        subject.adapter MockAdapter
+        subject.adapterObject.should_not be nil
+      end
+    end
+
+    describe "#field" do
+      it "should set fields array" do
+        subject.field :name
+        subject.fields.should_not be nil
+        subject.fields.should include(:name)
+      end
+
+      it "should define methods" do
+        subject.field :description
+        subject.instance_methods.should include(:description)
+        subject.instance_methods.should include(:description=)
+      end
+    end
+  end
+
+  describe "Class Methods" do
+    describe "#all" do
+      it "should call adapter#call" do
+        subject.adapterObject.should receive(:all)
+        subject.all
+      end
+
+      it "should call new on self class for items" do
+        subject.should receive(:new).twice
+        subject.adapterObject.should receive(:all).and_call_original
+        subject.all do end
+      end
+    end
+
+    describe "#find" do
+      it "should return class instance" do
+        subject.adapterObject.should receive(:get).and_call_original
+        subject.find do |instance|
+          instance.class.should eq described_class
+        end
+      end
+
+      it "should merge user data" do
+        subject.adapterObject.should receive(:get).and_call_original
+        subject.find do |instance|
+          instance.name.should eq 'User'
+        end
+      end
+    end
+  end
+
+  describe "Instance Methods" do
+    subject { described_class.new({name: 'Test'}) }
+
+    describe "#initialize" do
+      it "should set data" do
+        subject.name.should eq 'Test'
+      end
+    end
+
+    describe "#update" do
+      it "should call adapter#set" do
+        described_class.adapterObject.should receive(:set).and_call_original
+        subject.update
+      end
+
+      it "should merge user data" do
+        described_class.adapterObject.should receive(:set).and_call_original
+        subject.id = 0
+        subject.update name: "User" do
+          subject.errors.should be nil
+          subject.name.should eq 'User'
+        end
+      end
+
+      it "should set errors" do
+        subject.id == 2
+        subject.update do
+          subject.errors.should_not be nil
+        end
+      end
+    end
+
+    describe "#dirty?" do
+      it "should return true if there is no id" do
+        subject.dirty?.should eq true
+      end
+
+      it "should return false if there is and id" do
+        subject.id = 0
+        subject.dirty?.should eq false
+      end
+    end
+  end
+end