stockor 0.1.9 → 0.2

data/spec/server/jobs/fresh_books/import_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../../spec_helper'
+
+class FreshBooksImportSpec < Skr::TestCase
+
+    def around(&block)
+        VCR.use_cassette("freshbooks", VCR_OPTS) do
+            block.call
+        end
+    end
+
+    def perform_import(options = {})
+        Skr::Jobs::FreshBooks::Import.perform_now(
+            {
+                "domain"=>"testermctest-billing",
+                "api_key"=>"ba6642fa8d9b99e113ce0e5a1bf66de0",
+                "stage"=>"complete",
+                "ignored_ids"=>{
+                    "clients"=>[], "projects"=>[],
+                    "invoices"=>[], "time_entries"=>[], "staff"=>[]
+                }
+            }.merge(options)
+        )
+    end
+
+    def test_import
+        assert_difference ->{ Skr::Invoice.count }, 1 do
+            assert_difference ->{ Skr::Customer.count }, 3 do
+                perform_import
+            end
+        end
+        inv = Skr::Invoice.find_by_visible_id('1')
+        assert_equal inv.invoice_date.strftime('%Y-%m-%d'), '2016-01-26'
+    end
+
+    def test_invoice_balance
+        perform_import
+        inv = Skr::Invoice.find_by(visible_id: '1')
+        assert_equal 2198.75, inv.total.to_f
+        assert inv.fully_paid?
+        assert_equal 3, inv.lines.count
+        assert_equal 3, inv.lines.map(&:time_entry).compact.length
+    end
+
+    def test_ignored_ids
+        perform_import({'ignored_ids'=> {"time_entries" => ['7293'], 'clients' => ['27454'] }})
+        assert_nil Skr::TimeEntry.where("options ->>'freshbooks_id' = ?", '7293').first
+        assert_nil Customer.where("options ->>'freshbooks_id' = ?", '27454').first
+    end
+
+    def test_user_mappings
+        assert_no_difference ->{ Lanes::User.count } do
+            perform_import({'user_mappings' => { '1' => '1' }})
+        end
+    end
+
+    def test_customer_codes
+        customer = skr_customer(:billy)
+        assert_difference ->{ Skr::Customer.count }, 2 do
+            assert_difference ->{ customer.invoices.count }, 1 do
+                perform_import({'customer_codes' => {
+                                    '27454' => 'FOO',
+                                    '14694' => 'GOAT'
+                                }})
+                assert Skr::Customer.find_by_code('FOO')
+            end
+        end
+    end
+
+end

data/spec/server/jobs/fresh_books/retrieve_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../../spec_helper'
+require 'skr/jobs/fresh_books/retrieve'
+
+class FreshBooksRetrieveSpec < Skr::TestCase
+
+    def around(&block)
+        VCR.use_cassette("freshbooks", record: :none) do
+            block.call
+        end
+    end
+
+    def test_record_retrieval
+        job = Skr::Jobs::FreshBooks::Retrieve.perform_now(
+            'testermctest-billing',
+            'ba6642fa8d9b99e113ce0e5a1bf66de0'
+        )
+        data = job.job_status.data['output']
+
+        assert_equal ['testermctest@argosity.com'],
+                     data['staff'].map{|c| c['username'] }
+
+        assert_equal ["ClientThree", "Organization Two", "Organization One"],
+                     data['clients'].map{|c| c['organization'] }
+
+        assert_equal ["Project1", "Project2"],
+                     data['projects'].map{|c| c['name'] }
+
+        assert_equal ['0000001'],
+                     data['invoices'].map{|c| c['number'] }
+
+        assert_equal ["7293", "7292", "2432", "2430"],
+                     data['time_entries'].map{|c| c['time_entry_id'] }
+
+    end
+
+
+end

data/spec/server/models/address_spec.rb

@@ -2,9 +2,10 @@ require_relative '../spec_helper'
 
 class AddressSpec < Skr::TestCase
 
-    it "can be instantiated" do
-        model = Address.new
-        model.must_be_instance_of(Address)
+
+    it "can be converted to plain string" do
+        address = skr_address(:hg_billing).to_s(include: [:email,:phone])
+        assert_equal(address, "Hansel and Gretel\n499 Julianne Radial\nSouth Timmyville WI, 38200\nschuyler@krajcik.name\n379-772-4947 x945")
     end
 
 end

data/spec/server/models/gl_transaction_spec.rb

@@ -2,9 +2,9 @@ require_relative '../spec_helper'
 
 class GlTransactionSpec < Skr::TestCase
 
-    it "can be instantiated" do
-        model = GlTransaction.new
-        model.must_be_instance_of(GlTransaction)
+    it "can be queried with details" do
+        models = GlTransaction.with_details
+        assert models
     end
 
 end

data/spec/server/models/inv_line_spec.rb

@@ -2,9 +2,89 @@ require_relative '../spec_helper'
 
 class InvLineSpec < Skr::TestCase
 
-    it "can be instantiated" do
-        model = InvLine.new
-        model.must_be_instance_of(InvLine)
+    it "adjusts inventory" do
+        inv  = skr_invoice(:tiny)
+        yarn = skr_sku_loc(:yarn_def)
+        line = inv.lines.build(:sku_loc  => yarn, qty: 2)
+        assert_difference ->{ yarn.qty }, -2 do
+            assert line.save, 'line failed to save'
+        end
     end
 
+    it "can set price" do
+        tp = BigDecimal.new('112.54')
+        inv = Invoice.new( location: skr_location(:default), customer: skr_customer( :hubbard ) )
+        inv.lines.build(
+            sku_loc: skr_sku_loc(:hat_def),
+            qty: 1, price: tp
+        )
+        assert inv.save
+        line = inv.lines(true).first
+        assert_equal tp, line.price
+        assert_equal tp, line.extended_price
+    end
+
+    it "adjusts so_line qty" do
+        so = SalesOrder.new(customer: skr_customer(:billy))
+        so_line = so.lines.build( sku_loc: skr_sku_loc(:hat_def), qty: 2)
+        assert so.save
+        assert_equal 2, so_line.qty_allocated
+        inv = Invoice.new(sales_order: so)
+        inv.lines.from_sales_order!
+        assert inv.save
+        assert_equal 2, inv.lines.first.qty
+        assert_equal 2, so_line.reload.qty_invoiced
+        assert_equal 0, so_line.qty_allocated
+    end
+
+    it "posts to GL" do
+        inv  = skr_invoice(:tiny)
+        yarn = skr_sku_loc(:yarn_def)
+        line = inv.lines.build(sku_loc: yarn, qty: 2)
+        assert_difference ->{ yarn.qty }, -2 do
+            assert line.save, 'line failed to save'
+        end
+    end
+
+   it "can be reversed" do
+        inv = Invoice.new( location: skr_location(:default), customer: skr_customer(:hubbard) )
+        line = inv.lines.build( sku_loc: skr_sku_loc(:hat_def), qty: 2, price: 10.0 )
+        total = line.total
+        account = line.sku.gl_asset_account
+        assert_difference ->{ account.trial_balance }, (total * -1) do
+            assert inv.save, 'invoice failed to save'
+        end
+        assert_difference ->{ account.trial_balance }, BigDecimal.new('0.44') do
+            line.price -= BigDecimal.new('0.22')
+            assert line.save, 'failed to update inv line'
+        end
+        assert_difference ->{ account.trial_balance }, line.price do
+            line.qty -= 1
+            assert line.save, 'failed to update inv line'
+        end
+    end
+
+   it 'cannot be deleted' do
+       line = skr_inv_line(:tiny_hat)
+       line.destroy
+       assert line.errors.any?
+       assert_raise ActiveRecord::RecordNotFound do
+           line.reload
+       end
+   end
+
+   it 'sets position when set from attributes' do
+       inv = Invoice.new( location: skr_location(:default),
+                          customer: skr_customer( :hubbard ),
+                          lines_attributes: [
+                              {sku_loc_id: skr_sku_loc(:hat_def).id,   qty: 1, price: 0.22},
+                              {sku_loc_id: skr_sku_loc(:glove_def).id, qty: 2, price: 1.5},
+                              {sku_loc_id: skr_sku_loc(:misc_def).id,  qty: 3, price: 2.5}
+                          ])
+        assert inv.save, 'invoice failed to save'
+        inv.lines.pluck(:qty, :position).each do |qty, position|
+            assert_equal(qty.to_i, position, "Line #{qty} does not equal position")
+        end
+   end
+
 end

data/spec/server/models/invoice_spec.rb

@@ -2,9 +2,38 @@ require_relative '../spec_helper'
 
 class InvoiceSpec < Skr::TestCase
 
-    it "can be instantiated" do
-        model = Invoice.new
-        model.must_be_instance_of(Invoice)
+    it 'disallows location changes' do
+        inv = Skr::Invoice.new(sales_order: skr_sales_order(:tiny))
+        assert inv.save, 'failed to save'
+        inv.location = skr_location(:surplus)
+        refute inv.save
+        assert inv.errors[:location].any?
+    end
+
+    it 'cannot be posted to locked period' do
+        GlPeriod.create(year: Time.now.year, period: Time.now.month, is_locked: true)
+        inv = Skr::Invoice.new(customer: skr_customer(:billy))
+        refute inv.save, 'invoice saved even though period was locked'
+        assert inv.errors[:invoice_date].any?
+    end
+
+
+    it 'groups gl transactions together' do
+        inv = Skr::Invoice.new(customer: skr_customer(:billy))
+        inv.lines.build(sku_loc: skr_sku_loc(:glove_def), qty: 1, price: 10)
+        inv.lines.build(sku_loc: skr_sku_loc(:hat_def),   qty: 1, price: 20)
+        inv.lines.build(sku_loc: skr_sku_loc(:yarn_def),  qty: 1, price: 15)
+        ar_account = skr_gl_account(:ar)
+        invt_account = skr_gl_account(:inventory)
+        assert_difference ->{ ar_account.trial_balance }, BigDecimal.new('45.0') do
+            assert_difference ->{ invt_account.trial_balance }, BigDecimal.new('-45.0') do
+                assert_difference ->{ SkuTran.count }, 3 do
+                    assert_difference ->{ GlTransaction.count }, 1 do
+                        assert inv.save, 'failed to save'
+                    end
+                end
+            end
+        end
     end
 
 end

data/spec/server/models/payment_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../spec_helper'
+
+class PaymentSpec < Skr::TestCase
+
+    it "can be created" do
+        assert Payment.create(
+            amount: 42.42,
+            name: 'Test One, Two, Three',
+            category: skr_payment_category(:labor),
+            bank_account: skr_bank_account(:checking),
+            notes: 'A test payment'
+        ), "failed to create payment"
+    end
+
+    it "posts to general ledger" do
+        bank_account = skr_bank_account(:checking)
+        category = skr_payment_category(:labor)
+
+        assert_difference ->{
+            category.gl_account.trial_balance
+        }, BigDecimal.new('42.42') do
+
+            assert_difference ->{
+                bank_account.gl_account.trial_balance
+            }, BigDecimal.new('-42.42') do
+
+                Payment.create(
+                    amount: 42.42,
+                    name: 'Test One, Two, Three',
+                    category: category,
+                    bank_account: bank_account,
+                    notes: 'A test payment'
+                )
+
+            end
+        end
+
+    end
+
+end

data/spec/server/models/sales_order_spec.rb

@@ -6,7 +6,7 @@ class SalesOrderSpec < Skr::TestCase
     it "can be saved" do
         user = Lanes::User.find_by(login:'admin')
         model = SalesOrder.from_attribute_data({
-                    terms_id: skr_payment_term(:cashy).id,
+                    terms_id: skr_payment_term(:cash).id,
                     location_id: skr_location(:default).id,
                     customer_id: skr_customer(:billy).id,
                     billing_address: {

data/spec/server/models/so_line_spec.rb

@@ -2,9 +2,9 @@ require_relative '../spec_helper'
 
 class SoLineSpec < Skr::TestCase
 
-    it "can be instantiated" do
-        model = SoLine.new
-        model.must_be_instance_of(SoLine)
+    it "can load uom_choices" do
+        line = skr_so_line(:tiny_glove)
+        assert_equal ['PR', 'CS' ], line.uom_choices.pluck(:code)
     end
 
 end

data/spec/server/models/spec_helper_spec.rb

@@ -10,7 +10,7 @@ module FixtureHelpers
         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['visible_id'] ||= Skr::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')

data/spec/server/payment_spec.rb

@@ -0,0 +1,10 @@
+require_relative 'spec_helper'
+
+class PaymentSpec < Skr::TestCase
+
+    it "can be instantiated" do
+        model = Payment.new
+        model.must_be_instance_of(Payment)
+    end
+
+end

data/spec/server/print/form_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../spec_helper'
+
+class PrintSpec < Skr::TestCase
+
+    # for debugging add a generate(pdf) to one of the specs
+    def generate(pdf)
+        Lanes::SystemSettings.config.logo = File.open(
+            Pathname.new(__FILE__).dirname.join('../../fixtures/stockor.png')
+        )
+        begin
+            File.open('/tmp/skr-test.tex', 'w'){|f| f.write pdf.as_latex    }
+            File.open('/tmp/skr-test.pdf', 'w'){|f| f.write pdf.as_pdf.read }
+        rescue ErbLatex::LatexError=>e
+            puts e.log.gsub(/^\*\n/,'')
+            assert(false)
+        end
+    end
+
+    it "can generate default invoice" do
+        inv = skr_invoice(:tiny)
+        inv.update_attributes amount_paid: inv.total - 2.22
+        assert inv.update_attributes form: 'default'
+        pdf = Skr::Print::Form.new('invoice', inv.hash_code)
+        assert pdf.as_latex
+    end
+
+    it 'can generate labor invoice' do
+        inv = skr_invoice(:tiny)
+        assert inv.update_attributes form: 'labor'
+        pdf = Skr::Print::Form.new('invoice', inv.hash_code)
+        assert pdf.as_latex
+    end
+
+    it 'can generate sales order' do
+        so = skr_sales_order(:tiny)
+        pdf = Skr::Print::Form.new('sales-order', so.hash_code)
+        assert pdf.as_latex
+    end
+
+    it 'can generate checks' do
+        pymnt = skr_payment(:bigco)
+        pdf = Skr::Print::Form.new('payment', pymnt.hash_code)
+        assert pdf.as_latex
+    end
+
+
+end

data/spec/server/print/template_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../spec_helper'
+
+class PrintTemplateSpec < Skr::TestCase
+
+    let(:template) { Skr::Print::Template.get('sales-order') }
+
+    it "can list templates" do
+        assert_includes Skr::Print::Template.definitions.map(&:name), 'sales-order'
+        assert_includes Skr::Print::Template.definitions.map(&:name), 'invoice'
+    end
+
+    it 'lists choices' do
+        assert_includes template.choices, 'default'
+    end
+
+    it 'gets model class' do
+        assert_equal Skr::SalesOrder, template.model
+    end
+
+    describe 'path' do
+
+        it 'defaults to "default"' do
+            assert_equal Skr::Print::ROOT.join('types','sales-order','default.tex.erb'),
+                         template.path_for_record(Skr::SalesOrder.first)
+        end
+
+        it 'defaults to default if form doesnt exist' do
+            so = Skr::SalesOrder.first
+            so.form = 'a-custom-form'
+            assert_equal Skr::Print::ROOT.join('types','sales-order','default.tex.erb'),
+                         template.path_for_record(so)
+        end
+
+    end
+
+end

data/spec/server/spec_helper.rb

@@ -1,5 +1,7 @@
-require_relative '../../lib/stockor'
+require 'skr'
 require 'lanes/spec_helper'
+require 'webmock/minitest'
+require 'vcr'
 
 class Lanes::TestCase
     include Skr
@@ -39,4 +41,15 @@ module StockorFixtureTestPatches
     end
 end
 
+VCR_OPTS = {
+    record: :none
+}
+
+VCR.configure do |config|
+
+    config.cassette_library_dir = "spec/vcr"
+    config.hook_into :webmock
+    config.allow_http_connections_when_no_cassette = false
+end
+
 ActiveRecord::FixtureSet.send :include, StockorFixtureTestPatches

data/spec/server/time_entry_spec.rb

@@ -0,0 +1,10 @@
+require_relative 'spec_helper'
+
+class TimeEntrySpec < Skr::TestCase
+
+    it "can be instantiated" do
+        model = TimeEntry.new
+        model.must_be_instance_of(TimeEntry)
+    end
+
+end

data/spec/skr/components/SkuLinesSpec.coffee

@@ -0,0 +1,61 @@
+renderLines = (props) ->
+    new _.Promise (res, rej) ->
+        lines = LT.renderComponent(Skr.Components.SkuLines, {props})
+        _.delay -> res(lines)
+
+LAST_ROW_SELECTOR = '.grid-body .r:last-child'
+
+startEdit = (props) ->
+    props.screen.setState(isEditing: true)
+    new Promise (res, rej) ->
+        props.editor = true
+        renderLines(props).then (lines) ->
+            Lanes.Models.Sync.restorePerform ->
+                _.dom(lines).qs(LAST_ROW_SELECTOR).click()
+                remaining = 100
+                checkRendered = ->
+                    editors = LT.Utils.scryRenderedComponentsWithType(lines,
+                        Lanes.Components.Grid.RowEditor)
+                    if remaining and _.isEmpty(editors)
+                        remaining -= 1
+                        console.log remaining
+                        _.defer(checkRendered)
+                    else
+                        res(editor: editors[0], lines: lines)
+                checkRendered()
+
+ describe "Skr.Components.SkuLines", ->
+
+    beforeEach (done) ->
+        screen   = LT.makeScreen()
+        commands = new Lanes.Screens.Commands(screen, modelName: 'sales_order')
+        Lanes.Models.Sync.restorePerform =>
+            Skr.Models.SalesOrder.where({visible_id: 1}, include: 'lines')
+                .whenLoaded (orders) =>
+                    @sales_order = orders.first()
+                    lines = @sales_order.lines
+                    @props = {lines, commands, screen}
+                    done()
+
+    xit "renders lines", (done) ->
+        renderLines(@props).then (lines) =>
+            expect(_.dom(lines).qsa('.grid-body .r').length).toEqual( @props.lines.length )
+            done()
+
+#     it "displays the editor", (done) ->
+#         startEdit(@props).then ({lines, editor}) =>
+#             sol = @props.lines.last()
+#             expect(_.pluck( _.dom(editor).qsa('input'), 'value'))
+#                 .toEqual([sol.sku_code, sol.description, sol.uom_code, "#{sol.qty}", sol.price.toString()])
+#             done()
+
+#     it "saves values when edited", (done) ->
+#         startEdit(@props).then ({lines, editor}) =>
+#             _.dom(editor).qs('input[name=price]').setValue('42.21')
+#             _.dom(editor).qs('input[name=qty]').setValue(12)
+#             _.dom(editor).qs('button.save').click()
+#             _.defer =>
+#                 sol = @props.lines.last()
+#                 expect(sol.qty).toEqual(12)
+#                 expect(sol.price.toString()).toEqual('42.21')
+#                 done()

data/spec/skr/models/BankAccountSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Models.BankAccount", ->
+
+    it "can be instantiated", ->
+        model = new Skr.Models.BankAccount()
+        expect(model).toEqual(jasmine.any(Skr.Models.BankAccount))

data/spec/skr/models/CustomerProjectSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Models.CustomerProject", ->
+
+    it "can be instantiated", ->
+        model = new Skr.Models.CustomerProject()
+        expect(model).toEqual(jasmine.any(Skr.Models.CustomerProject))

data/spec/skr/models/CustomerSpec.coffee

@@ -3,7 +3,7 @@ describe "Skr.Models.Customer", ->
     beforeEach ->
         Lanes.Test.ModelSaver.setUser('admin')
 
-    xit "sends failure messages when code isn't set", (done) ->
+    it "sends failure messages when code isn't set", (done) ->
         model = new Skr.Models.Customer()
         Lanes.Test.ModelSaver.perform(model, done).then (save) ->
             expect(model.errors?.code).toContain("blank")
@@ -17,4 +17,4 @@ describe "Skr.Models.Customer", ->
         )
 
         Lanes.Test.ModelSaver.perform(model, done).then (save) ->
-            expect(model.errors).toBeNull()
+            expect(model.errors).toBeUndefined()

data/spec/skr/models/PaymentSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Models.Payment", ->
+
+    it "can be instantiated", ->
+        model = new Skr.Models.Payment()
+        expect(model).toEqual(jasmine.any(Skr.Models.Payment))

data/spec/skr/models/SalesOrderSpec.coffee

@@ -1,7 +1,23 @@
 describe "Skr.Models.SalesOrder", ->
 
-    xit "must have a customer to save", (done)->
-        model = new Skr.Models.SalesOrder()
-        Lanes.Test.ModelSaver.perform(model, done).then (save)->
-            expect(save.error).toHaveBeenCalled()
-            expect(model.errors.customer).toContain("is not set")
+
+    it "it calculates total", ->
+        so = new Skr.Models.SalesOrder()
+        so.lines.add(sku_code: 'TEST', price: 2.12, qty:1)
+        expect(so.total).toEqual(jasmine.any(_.bigDecimal))
+        expect(so.total.toString()).toEqual('2.12')
+        so.order_total = '1.42'
+        expect(so.order_total.toString()).toEqual('1.42')
+        expect(so.total.toString()).toEqual('1.42')
+        expect(so.total).toEqual(jasmine.any(_.bigDecimal))
+
+    it 'updates total and triggers change when lines change', ->
+        so = new Skr.Models.SalesOrder()
+        line = so.lines.add(sku_code: 'TEST', price: 2.12, qty:1)
+        line.price = 3.42
+        expect(so.total.toString()).toEqual('3.42')
+        spy = jasmine.createSpy('on change')
+        so.on('change', spy)
+        line.price = 233.111
+        expect(so.total.toString()).toEqual('233.111')
+        expect(spy).toHaveBeenCalled()

data/spec/skr/models/SoLineSpec.coffee

@@ -1,5 +1,10 @@
 describe "Skr.Models.SoLine", ->
 
-    it "can be instantiated", ->
+    it "can sets properties from the uom", ->
         model = new Skr.Models.SoLine()
-        expect(model).toEqual(jasmine.any(Skr.Models.SoLine))
+        spy = jasmine.createSpy('onuom')
+        model.on("change:uom", spy)
+        model.set(uom: new Skr.Models.Uom(size: 10, code: 'CS'))
+        expect(spy).toHaveBeenCalled()
+        expect(model.uom_size).toEqual(10)
+        expect(model.uom_code).toEqual('CS')

data/spec/skr/models/TimeEntrySpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Models.TimeEntry", ->
+
+    it "can be instantiated", ->
+        model = new Skr.Models.TimeEntry()
+        expect(model).toEqual(jasmine.any(Skr.Models.TimeEntry))

data/spec/skr/screens/bank-maint/BankMaintSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Screens.BankMaint", ->
+
+    it "can be rendered", ->
+        screen = LT.renderComponent(Skr.Screens.BankMaint)
+        expect(_.dom(screen).text).toMatch("Hello")

data/spec/skr/screens/customer-projects/CustomerProjectsSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Screens.CustomerProjects", ->
+
+    xit "can be rendered", ->
+        screen = LT.renderComponent(Skr.Screens.CustomerProjects)
+        expect(screen.getDOMNode().textContent).toMatch("Hello")

data/spec/skr/screens/fresh-books-import/FreshBooksImportSpec.coffee

@@ -0,0 +1 @@
+describe "Skr.Screens.FreshBooksImport", ->

data/spec/skr/screens/gl-accounts/GlAccountsSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Screens.GlAccounts", ->
+
+    it "can be rendered", ->
+        screen = LT.renderComponent(Skr.Screens.GlAccounts)
+        expect(_.dom(screen).text).toMatch("Hello")

data/spec/skr/screens/invoice/InvoiceSpec.coffee

@@ -0,0 +1,5 @@
+describe "Skr.Screens.Invoice", ->
+
+    it "can be rendered", ->
+        screen = LT.renderComponent(Skr.Screens.Invoice)
+        expect(screen).toBeTruthy()