fron 0.1.4 → 0.2.0rc1

data/spec/core/adapter/local_spec.rb

@@ -1,65 +0,0 @@
-require 'fron/storage'
-require 'fron/core'
-
-describe Fron::Adapters::LocalAdapter do
-
-  subject { described_class.new({fields: [:name]}) }
-  let(:proc) { Proc.new {} }
-
-  describe "#all" do
-    it "should call localStorage#all" do
-      Fron::Storage::LocalStorage.should receive(:all).once
-      subject.all &proc
-    end
-
-    it "should run the block" do
-      proc.should receive(:call)
-      subject.all &proc
-    end
-  end
-
-  describe "#get" do
-    it "should call localStorage#get" do
-      Fron::Storage::LocalStorage.should receive(:get).once
-      subject.get 0, &proc
-    end
-
-    it "should run the block" do
-      proc.should receive(:call)
-      subject.get 0, &proc
-    end
-  end
-
-  describe "#set" do
-    it "should call localStorage#set" do
-      Fron::Storage::LocalStorage.should receive(:set).once
-      subject.set double(id: 0), {name: 'test'}, &proc
-    end
-
-    it "should run the block with nil if there are no errors" do
-      proc.should receive(:call).with nil, {name: 'test', id: 0}
-      subject.set double(id: 0), {name: 'test'}, &proc
-    end
-
-    it "should run the block with erros if ther are any" do
-      proc.should receive(:call).with({name: ["can't be blank"]}, {})
-      subject.set double(id: 0), {name: ''}, &proc
-    end
-
-    it "should add id if there isn't any" do
-      result = subject.set double(id: nil), {name: ''}, &proc
-      result[:id].should_not be nil
-    end
-  end
-
-  describe "#validate" do
-    it "should return errors for undefined fields" do
-      subject.validate.should eq({name: ["can't be blank"]})
-    end
-
-    it "should return errors for empty fields" do
-      subject.validate({name: ''}).should eq({name: ["can't be blank"]})
-    end
-  end
-end
-

data/spec/core/adapter/rails_spec.rb

@@ -1,77 +0,0 @@
-require 'fron/core'
-require 'fron/storage'
-
-class TestModel < Fron::Model
-end
-
-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 }
-  let(:model) { TestModel.new({ id: 0 }) }
-  let(:newModel) { TestModel.new }
-
-  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, json: ''
-      end
-      proc.should receive(:call)
-      subject.set newModel, {}, &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, json: ''
-      end
-      proc.should receive(:call)
-      subject.set model, {}, &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', 'error'
-      subject.set model, {}, &proc
-    end
-  end
-end

data/spec/core/application_spec.rb

@@ -1,35 +0,0 @@
-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/configuration_spec.rb

@@ -1,20 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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/model_spec.rb

@@ -1,125 +0,0 @@
-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(model,data,&block)
-    if model.id == 0
-      block.call(nil, data)
-    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

data/spec/core/router_spec.rb

@@ -1,124 +0,0 @@
-require 'fron/core'
-
-module Fron
-  class Router
-    attr_reader :routes
-  end
-end
-
-class TestRouteController < Fron::Controller
-  route "show/:id", :show
-  route "*", :test
-
-  def show
-  end
-  def test
-  end
-end
-
-describe Fron::Router do
-
-  subject { described_class.new [], config }
-  let(:window) { DOM::Window }
-  let(:window_listeners) {window.instance_variable_get("@listeners")}
-  let(:controller) { TestRouteController.new }
-  let(:config) { double :config, {
-      injectBlock: nil,
-      logger: double(:logger,info:  true),
-      main: double(:main, :"<<" => true, "empty" => true)
-    }
-  }
-
-  before { window.off }
-
-  describe "DSL" do
-    describe "#map" do
-      it "should retrun '*' path for action only" do
-        result = described_class.map :test
-        result[:path].should eq "*"
-        result[:action].should eq :test
-      end
-
-      it "should return regexp for path" do
-        result = described_class.map "/test", :test
-        result[:path][:regexp].should eq Regexp.new "^/test"
-        result[:path][:map].should eq []
-        result[:action].should eq :test
-      end
-
-      it 'should parse string as action' do
-        result = described_class.map :test
-        result[:action].should eq :test
-        result[:controller].should be nil
-      end
-
-      it 'should parse controllers as controller' do
-        result = described_class.map Fron::Controller
-        result[:controller].should_not be nil
-        result[:controller].class.should eq Fron::Controller
-        result[:action].should eq nil
-      end
-    end
-  end
-
-  describe "#route" do
-    it "should deletage if controller is given" do
-      subject.routes << {path: "*", controller: controller}
-      subject.should receive(:route).twice.and_call_original
-      subject.route
-    end
-
-    it "should call controller action" do
-      subject.routes << {path: "*", controller: controller}
-      controller.should receive(:test).once
-      subject.route
-    end
-
-    it "should call controller action with params" do
-      controller.should receive(:show).once.with({id: '10'})
-      subject.routes << {path: "*", controller: controller}
-      subject.route 'show/10'
-    end
-
-    it "should remove the matched portion of the hash" do
-      controller.should receive(:show).once.with({id: '10'})
-      subject.routes << {path: {regexp: Regexp.new("test/")}, controller: controller}
-      subject.route 'test/show/10'
-    end
-  end
-
-  describe "#applyRoute" do
-    it "should call before methods" do
-      controller.should receive(:empty).once
-      subject.applyRoute controller, {action: 'show'}
-    end
-
-    it "should call action method" do
-      controller.should receive(:show).once
-      subject.applyRoute controller, {action: 'show'}
-    end
-
-    it 'should log the route' do
-      config.logger.should receive(:info).once
-      subject.applyRoute controller, {action: 'show'}
-    end
-
-    it "should append it the the main" do
-      config.main.should receive(:<<).once
-      subject.applyRoute controller, {action: 'show'}
-    end
-  end
-
-  describe "#initalize" do
-    it 'should listen on window load' do
-      subject
-      window_listeners['load'].should_not be nil
-    end
-
-    it 'should listen on window hashchange' do
-      subject
-      window_listeners['hashchange'].should_not be nil
-    end
-  end
-
-end