joosy 1.2.0.alpha.41 → 1.2.0.alpha.51

data/spec/joosy/core/widget_spec.coffee

@@ -1,36 +1,375 @@
 describe "Joosy.Widget", ->
 
-  beforeEach ->
-    class @Widget extends Joosy.Widget
-    @widget = new @Widget
-
-  it "integrates with Router", ->
-    target = sinon.stub Joosy.Router, 'navigate'
-    @widget.navigate 'there'
-    expect(target.callCount).toEqual 1
-    expect(target.alwaysCalledWithExactly 'there').toBeTruthy()
-    Joosy.Router.navigate.restore()
-
-  it "loads", ->
-    spies = []
-    spies.push sinon.spy()
-    spies.push sinon.spy(@widget, '__assignElements')
-    spies.push sinon.spy(@widget, '__delegateEvents')
-    spies.push sinon.spy(@widget, '__runAfterLoads')
-
-    @widget.data = tested: true
-    @Widget.view spies[0]
-    @parent = new Joosy.Layout
-
-    target = @widget.__load @parent, @$ground
-
-    expect(target).toBe @widget
-    expect(spies[0].getCall(0).calledOn()).toBeFalsy()
-    expect(spies[0].getCall(0).args[0].tested).toBe true
-    expect(spies).toBeSequenced()
-
-  it "unloads", ->
-    sinon.spy @widget, '__runAfterUnloads'
-    @widget.__unload()
-    expect(@widget.__runAfterUnloads.callCount).toEqual 1
-    expect(@widget.__runAfterUnloads.getCall(0).calledOn()).toBeFalsy()
+  @beforeEach ->
+    Joosy.templater
+      resolveTemplate: (section, template) -> template
+      buildView: (template) -> (-> template) # ಠ_ಠ
+
+  describe 'callback caller', ->
+    beforeEach ->
+      @spies = spies = {}
+      entries = ['a', 'b', 'c', 'd']
+
+      for instance in entries
+        for filter in ['paint', 'beforePaint', 'erase', 'fetch']
+          spies[instance+'/'+filter] = sinon.spy()
+
+      class @A extends Joosy.Widget
+        @view """
+          <div id="content"></div>
+        """
+
+        @paint (done)       -> spies['a/paint'](); done()
+        @beforePaint (done) -> spies['a/beforePaint'](); done()
+        @erase (done)       -> spies['a/erase'](); done()
+        @fetch (done)       -> spies['a/fetch'](); done()
+
+      class @B extends Joosy.Widget
+        @view """
+          <div id="subcontent"></div>
+        """
+
+        @paint (done)       -> spies['b/paint'](); done()
+        @beforePaint (done) -> spies['b/beforePaint'](); done()
+        @erase (done)       -> spies['b/erase'](); done()
+        @fetch (done)       -> spies['b/fetch'](); done()
+
+      class @C extends Joosy.Widget
+        @paint (done)       -> spies['c/paint'](); done()
+        @beforePaint (done) -> spies['c/beforePaint'](); done()
+        @erase (done)       -> spies['c/erase'](); done()
+        @fetch (done)       -> spies['c/fetch'](); done()
+
+      class @D extends Joosy.Widget
+        @paint (done)       -> spies['d/paint'](); done()
+        @beforePaint (done) -> spies['d/beforePaint'](); done()
+        @erase (done)       -> spies['d/erase'](); done()
+        @fetch (done)       -> spies['d/fetch'](); done()
+
+      @a = new @A
+      @b = new @B
+      @c = new @C 'params', @b
+      @d = new @D
+
+      for instance in entries
+        sinon.spy @[instance], '__load'
+        sinon.spy @[instance], '__unload'
+
+      @nestingMap = 
+        '#content': 
+          instance: @b
+          nested:
+            '#subcontent': {instance: @d}
+
+    it 'calls paint callbacks', ->
+      @a.__bootstrap @nestingMap, @$ground
+
+      expect(@spies["a/paint"].callCount).toEqual 1
+      expect(@spies["b/paint"].callCount).toEqual 0
+      expect(@spies["c/paint"].callCount).toEqual 0
+      expect(@spies["a/beforePaint"].callCount).toEqual 1
+      expect(@spies["b/beforePaint"].callCount).toEqual 0
+      expect(@spies["c/beforePaint"].callCount).toEqual 0
+      expect(@spies['a/fetch'].callCount).toEqual 1
+      expect(@spies['b/fetch'].callCount).toEqual 1
+      expect(@spies['c/fetch'].callCount).toEqual 0
+      expect(@spies['a/erase'].callCount).toEqual 0
+      expect(@spies['b/erase'].callCount).toEqual 0
+      expect(@spies['c/erase'].callCount).toEqual 0
+
+      @c.__bootstrap {}, $('#content', @$ground)
+
+      ['paint', 'beforePaint'].each (filter) =>
+        expect(@spies["a/#{filter}"].callCount).toEqual 1
+        expect(@spies["b/#{filter}"].callCount).toEqual 0
+        expect(@spies["c/#{filter}"].callCount).toEqual 1
+
+      expect(@spies['a/fetch'].callCount).toEqual 1
+      expect(@spies['b/fetch'].callCount).toEqual 1
+      expect(@spies['c/fetch'].callCount).toEqual 1
+      expect(@spies['a/erase'].callCount).toEqual 0
+      expect(@spies['b/erase'].callCount).toEqual 1
+      expect(@spies['c/erase'].callCount).toEqual 0
+
+    it 'calls load/unload callbacks', ->
+      @a.__bootstrap @nestingMap, @$ground
+
+      expect(@a.__load.callCount).toEqual 1
+      expect(@b.__load.callCount).toEqual 1
+      expect(@c.__load.callCount).toEqual 0
+      expect(@d.__load.callCount).toEqual 1
+      expect(@a.__unload.callCount).toEqual 0
+      expect(@b.__unload.callCount).toEqual 0
+      expect(@c.__unload.callCount).toEqual 0
+      expect(@d.__unload.callCount).toEqual 0
+
+      @c.__bootstrap {}, $('#content', @$ground)
+
+      expect(@a.__load.callCount).toEqual 1
+      expect(@b.__load.callCount).toEqual 1
+      expect(@c.__load.callCount).toEqual 1
+      expect(@d.__load.callCount).toEqual 1
+      expect(@a.__unload.callCount).toEqual 0
+      expect(@b.__unload.callCount).toEqual 1
+      expect(@c.__unload.callCount).toEqual 0
+      expect(@d.__unload.callCount).toEqual 1
+
+  describe 'widgets manager', ->
+
+    @beforeEach ->
+
+      D = class @D extends Joosy.Widget
+        @view "D"
+
+      C = class @C extends Joosy.Widget
+        @view "C"
+
+      B = class @B extends Joosy.Widget
+        @view """
+          <div id="c"></div>
+        """
+
+        @mapWidgets
+          '#c': -> C
+
+      class @A extends Joosy.Widget
+        @view """
+          <div id="b"></div>
+        """
+
+        @mapWidgets
+          '#b': B
+
+    it 'bootstraps registered widgets', ->
+      (new @A).__bootstrapDefault @$ground
+      expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c">C</div></div>'
+
+    it 'bootstraps registered independent widgets', ->
+      @C.fetch (complete) -> setTimeout complete, 0
+      @C.independent()
+
+      runs ->
+        (new @A).__bootstrapDefault @$ground
+        expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"></div></div>'
+
+      waits 0
+
+      runs ->
+        expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c">C</div></div>'
+
+    it 'registeres widgets on the fly', ->
+      a = new @A
+      a.__bootstrapDefault @$ground
+      expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c">C</div></div>'
+
+      a.registerWidget '#b', @D
+
+      expect(@$ground.html()).toEqualHTML '<div id="b">D</div>'
+
+    it 'replaces widget', ->
+      a = new @A
+      a.__bootstrapDefault @$ground
+      expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c">C</div></div>'
+
+      d = a.registerWidget '#b', @D
+      sinon.spy d, '__unload'
+
+      a.replaceWidget d, @C
+      expect(@$ground.html()).toEqualHTML '<div id="b">C</div>'
+      expect(d.__unload.callCount).toEqual 1
+
+  describe 'synchronizer', ->
+
+    @beforeEach ->
+      class @A extends Joosy.Widget
+        @view """
+          <div id="b"></div>
+        """
+
+      class @B extends Joosy.Widget
+        @view """
+          <div id="c"></div>
+          <div id="d"></div>
+        """
+
+      class @C extends Joosy.Widget
+        @view """
+          <div id="e"></div>
+          <div id="f"></div>
+        """
+
+      class @D extends Joosy.Widget
+        @view "D"
+
+      class @E extends Joosy.Widget
+        @view "E"
+
+      class @F extends Joosy.Widget
+        @view "F"
+
+      ['a', 'b', 'c', 'd', 'e', 'f'].each (instance) =>
+        @[instance] = new @[instance.toUpperCase()] 'params'
+
+      @nestingMap =
+        '#b':
+          instance: @b
+          nested:
+            '#d': {instance: @d}
+            '#c':
+              instance: @c
+              nested:
+                '#e': {instance: @e}
+                '#f': {instance: @f}
+
+    describe 'fetcher', ->
+
+      it 'triggers when no nesting defined', ->
+        @f.__fetch(@nestingMap)
+        expect(@f.__triggeredEvents?['section:fetched']).toEqual true
+
+      it 'triggers whole dependency tree synchronously', ->
+        @a.__fetch(@nestingMap)
+        expect(@a.__triggeredEvents?['section:fetched']).toEqual true
+        expect(@b.__triggeredEvents?['section:fetched']).toEqual true
+        expect(@c.__triggeredEvents?['section:fetched']).toEqual true
+        expect(@d.__triggeredEvents?['section:fetched']).toEqual true
+        expect(@e.__triggeredEvents?['section:fetched']).toEqual true
+        expect(@f.__triggeredEvents?['section:fetched']).toEqual true
+
+      it 'triggers whole dependency tree asynchronously', ->
+        @F.fetch (complete) -> setTimeout complete, 0
+        @B.fetch (complete) -> setTimeout complete, 100
+
+        runs ->
+          @a.__fetch(@nestingMap)
+          expect(@a.__triggeredEvents?['section:fetched']).toBeUndefined()
+          expect(@b.__triggeredEvents?['section:fetched']).toBeUndefined()
+          expect(@c.__triggeredEvents?['section:fetched']).toBeUndefined()
+          expect(@d.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@e.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@f.__triggeredEvents?['section:fetched']).toBeUndefined()
+
+        waits 0
+
+        runs ->
+          expect(@a.__triggeredEvents?['section:fetched']).toBeUndefined()
+          expect(@b.__triggeredEvents?['section:fetched']).toBeUndefined()
+          expect(@c.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@d.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@e.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@f.__triggeredEvents?['section:fetched']).toEqual true
+
+        waits 100
+
+        runs ->
+          expect(@a.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@b.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@c.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@d.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@e.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@f.__triggeredEvents?['section:fetched']).toEqual true
+
+      it 'skips independent nestings within tree', ->
+        @C.fetch (complete) -> setTimeout complete, 0
+        @C.independent()
+
+        runs ->
+          @a.__fetch(@nestingMap)
+          expect(@a.__triggeredEvents?['section:fetched']).toEqual true
+          expect(@d.__triggeredEvents?['section:fetched']).toEqual true
+
+    describe 'bootstrap', ->
+
+      describe 'dependent', ->
+
+        it 'loads when no nesting defined', ->
+          @f.__bootstrap @nestingMap, @$ground
+          expect(@$ground.html()).toEqual 'F'
+
+        it 'loads whole dependency tree synchronously', ->
+          @a.__bootstrap @nestingMap, @$ground
+          expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"><div id="e">E</div><div id="f">F</div></div><div id="d">D</div></div>'
+
+        it 'loads whole dependency tree asynchronously', ->
+          @F.fetch (complete) -> setTimeout complete, 0
+          @B.fetch (complete) -> setTimeout complete, 100
+
+          runs ->
+            @a.__bootstrap @nestingMap, @$ground
+            expect(@$ground.html()).toEqualHTML ''
+
+          waits 0
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML ''
+
+          waits 100
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"><div id="e">E</div><div id="f">F</div></div><div id="d">D</div></div>'
+
+        it 'skips independent nestings within tree', ->
+          @C.fetch (complete) -> setTimeout complete, 0
+          @C.independent()
+
+          @a.__bootstrap @nestingMap, @$ground
+          expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"></div><div id="d">D</div></div>'
+
+      describe 'independent', ->
+
+        it 'loads independent children synchronously if they managed to fetch', ->
+          @A.fetch (complete) -> setTimeout complete, 100
+
+          @C.fetch (complete) -> setTimeout complete, 0
+          @C.independent()          
+
+          runs ->
+            @a.__bootstrap @nestingMap, @$ground
+
+          waits 100
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"><div id="e">E</div><div id="f">F</div></div><div id="d">D</div></div>'
+
+        it 'loads whole dependency tree', ->
+          @C.fetch (complete) -> setTimeout complete, 0
+          @C.independent()
+
+          @E.fetch (complete) -> setTimeout complete, 100
+          @E.independent()
+
+          runs ->
+            @a.__bootstrap @nestingMap, @$ground
+            expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"></div><div id="d">D</div></div>'
+
+          waits 0
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"><div id="e"></div><div id="f">F</div></div><div id="d">D</div></div>'
+
+          waits 100
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"><div id="e">E</div><div id="f">F</div></div><div id="d">D</div></div>'
+
+      describe 'mixed', ->
+
+        it 'loads whole dependency tree', ->
+          @B.fetch (complete) -> setTimeout complete, 0
+          @B.independent()
+
+          @E.fetch (complete) -> setTimeout complete, 100
+
+          runs ->
+            @a.__bootstrap @nestingMap, @$ground
+            expect(@$ground.html()).toEqualHTML '<div id="b"></div>'
+
+          waits 0
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML '<div id="b"></div>'
+
+          waits 100
+
+          runs ->
+            expect(@$ground.html()).toEqualHTML '<div id="b"><div id="c"><div id="e">E</div><div id="f">F</div></div><div id="d">D</div></div>'

data/spec/joosy/environments/amd_spec.coffee

@@ -0,0 +1,38 @@
+describe "Joosy", ->
+
+  it "loads", ->
+    result = false
+
+    runs ->
+      requirejs ['joosy'], (joosy) ->
+        result = true
+        expect(joosy.Application).toBeDefined()
+
+    waitsFor (-> result), 'Unable to download Joosy', 1000
+
+  it "allows for separate module inclusion", ->
+    result = false
+
+    runs ->
+      requirejs ['joosy/module'], (module) ->
+        result = true
+        expect(Object.isFunction module.hasAncestor).toBeTruthy()
+
+    waitsFor (-> result), 'Unable to download Joosy', 1000
+
+  it "registers internal components as modules", ->
+    expect(Object.keys(require.s.contexts._.registry).sortBy()).toEqual [
+      'joosy/application',
+      'joosy/layout',
+      'joosy/modules/dom',
+      'joosy/modules/events',
+      'joosy/modules/filters',
+      'joosy/modules/log',
+      'joosy/modules/renderer',
+      'joosy/modules/time_manager',
+      'joosy/page',
+      'joosy/resources/watcher',
+      'joosy/router',
+      'joosy/templaters/jst',
+      'joosy/widget'
+    ]

data/spec/joosy/environments/global_spec.coffee

@@ -0,0 +1,21 @@
+describe "Joosy", ->
+
+  it "loads", ->
+    expect(Joosy).toBeDefined()
+
+  it "keeps environment clean", ->
+    result = false
+    ghetto = {}
+
+    runs ->
+      $.ajax
+        url: '../build/joosy.js'
+        dataType: 'text'
+        success: (script) ->
+          (new Function( "with(this) { " + script + "}")).call(ghetto)
+          result = true
+
+    waitsFor (-> result), 'Unable to download Joosy', 1000
+
+    runs ->
+      expect(Object.keys ghetto).toEqual ['Joosy', 'Metamorph']

data/spec/joosy/extensions/form/form_spec.coffee

@@ -54,7 +54,7 @@ describe "Joosy.Form", ->
 
     it "should properly act with options", ->
       formWithProperties = new Joosy.Form @nudeForm, invalidationClass: 'fluffy'
-      expect(formWithProperties.container).toEqual @nudeForm
+      expect(formWithProperties.$container).toEqual @nudeForm
       expect(formWithProperties.invalidationClass).toEqual 'fluffy'
       expect(formWithProperties.$fields().length).toEqual 5
 
@@ -62,7 +62,7 @@ describe "Joosy.Form", ->
 
     it "should properly act with callback", ->
       formWithCallback = new Joosy.Form @putForm, callback=sinon.spy()
-      expect(formWithCallback.container).toEqual @putForm
+      expect(formWithCallback.$container).toEqual @putForm
       expect(formWithCallback.invalidationClass).toEqual 'field_with_errors'
       expect(formWithCallback.success).toBe callback
       expect(formWithCallback.$fields().length).toEqual 2
@@ -107,15 +107,15 @@ describe "Joosy.Form", ->
       expect(@nudeForm.$fields()[3].checked).toEqual false
       expect(@nudeForm.$fields()[4].value).toEqual 'zxc'
       expect(@nudeForm.$fields()[4].checked).toEqual true
-      expect(@nudeForm.container.attr('method').toLowerCase()).toEqual 'post'
-      expect(@nudeForm.container.attr 'action').toEqual '/tests/1'
+      expect(@nudeForm.$container.attr('method').toLowerCase()).toEqual 'post'
+      expect(@nudeForm.$container.attr 'action').toEqual '/tests/1'
       expect(@nudeForm.__resource).toEqual @resource
 
     it "should fill form with camelized properties", ->
       @putForm.fill @resource
       expect(@putForm.$fields()[0].value).toEqual 'baz'
-      expect(@putForm.container.attr('method').toLowerCase()).toEqual 'post'
-      expect(@putForm.container.attr 'action').toEqual '/tests/1'
+      expect(@putForm.$container.attr('method').toLowerCase()).toEqual 'post'
+      expect(@putForm.$container.attr 'action').toEqual '/tests/1'
 
     it "should fill form with any properties", ->
       @exactForm.fill @resource
@@ -133,13 +133,13 @@ describe "Joosy.Form", ->
         action: @resource.memberPath(from: 'calculate')
       expect(@nudeForm.$fields()[0].value).toEqual 'foo'
       expect(@nudeForm.$fields()[1].value).toEqual 'bar'
-      expect(@nudeForm.container.attr 'action').toEqual '/tests/1/calculate'
+      expect(@nudeForm.$container.attr 'action').toEqual '/tests/1/calculate'
 
       resource = @Test.build 'someId'
 
       @nudeForm.fill resource,
         action: resource.memberPath(from: 'calculate')
-      expect(@nudeForm.container.attr 'action').toEqual '/tests/someId/calculate'
+      expect(@nudeForm.$container.attr 'action').toEqual '/tests/someId/calculate'
 
     it "should handle field name properly", ->
       expect(@nudeForm.concatFieldName 'resource', 'key').toEqual 'resource[key]'
@@ -189,14 +189,14 @@ describe "Joosy.Form", ->
       it 'should allow multiple submit', ->
         @nudeForm = new Joosy.Form @nudeForm
         3.times =>
-          @nudeForm.container.submit()
+          @nudeForm.$container.submit()
         expect(@requests.length).toEqual 3
 
       it 'should optionally prevent multiple submit', ->
         @nudeForm = new Joosy.Form @nudeForm, debounce: true
         [200, 404, 500].each (code) =>
           3.times =>
-            @nudeForm.container.submit()
+            @nudeForm.$container.submit()
           expect(@requests.length).toEqual 1
           @requests[0].respond(code, {}, '{}')
           expect(@requests.length).toEqual 1
@@ -205,21 +205,21 @@ describe "Joosy.Form", ->
     describe 'Global debouncing enabled', ->
 
       beforeEach ->
-        Joosy.Application.debounceForms = true
+        Joosy.Form.debounceForms = true
 
       afterEach ->
-        Joosy.Application.debounceForms = false
+        Joosy.Form.debounceForms = false
 
       it 'should optionally allow multiple submit', ->
         @nudeForm = new Joosy.Form @nudeForm, debounce: false
         3.times =>
-          @nudeForm.container.submit()
+          @nudeForm.$container.submit()
         expect(@requests.length).toEqual 3
 
       it 'should prevent multiple submit', ->
         @nudeForm = new Joosy.Form @nudeForm
         3.times =>
-          @nudeForm.container.submit()
+          @nudeForm.$container.submit()
         expect(@requests.length).toEqual 1
 
   describe "Callbacks", ->
@@ -227,7 +227,7 @@ describe "Joosy.Form", ->
     beforeEach ->
       @nudeForm = new Joosy.Form @nudeForm, @spy=sinon.spy()
       @nudeForm.fill @resource
-      @nudeForm.container.submit()
+      @nudeForm.$container.submit()
       @target = @server.requests.last()
 
     it "should trigger 'success'", ->
@@ -260,7 +260,7 @@ describe "Joosy.Form", ->
     it "should clear fields before another submit", ->
       @target.respond 422, 'Content-Type': 'application/json', '{"foo": "error!"}'
       expect($(@nudeForm.$fields()[0]).attr 'class').toEqual 'field_with_errors'
-      @nudeForm.container.submit()
+      @nudeForm.$container.submit()
       expect($(@nudeForm.$fields()[0]).attr 'class').toNotEqual 'field_with_errors'
 
     it "should trigger 'before' and do default action if it returns true", ->
@@ -268,7 +268,7 @@ describe "Joosy.Form", ->
       expect($(@nudeForm.$fields()[0]).attr 'class').toEqual 'field_with_errors'
       @nudeForm.before = sinon.spy ->
         true
-      @nudeForm.container.submit()
+      @nudeForm.$container.submit()
       expect($(@nudeForm.$fields()[0]).attr 'class').toNotEqual 'field_with_errors'
       expect(@nudeForm.before.callCount).toEqual 1
 
@@ -277,7 +277,7 @@ describe "Joosy.Form", ->
       expect($(@nudeForm.$fields()[0]).attr 'class').toEqual 'field_with_errors'
       @nudeForm.before = sinon.spy ->
         false
-      @nudeForm.container.submit()
+      @nudeForm.$container.submit()
       expect($(@nudeForm.$fields()[0]).attr 'class').toEqual 'field_with_errors'
       expect(@nudeForm.before.callCount).toEqual 1
 

data/spec/joosy/extensions/form/helpers/forms_spec.coffee

@@ -47,7 +47,7 @@ describe "Joosy.Helpers.Form", ->
 
     it "renders formFor", ->
       callback = sinon.spy()
-      expect(h.formFor resource, callback).toMatch /<form id=".*"><\/form>/
+      expect(h.formFor resource, callback).toBeTag 'form', '', id: /.*/
       expect(callback.callCount).toEqual 1
       expect(callback.args[0][0].label?).toBeTruthy()
 

data/spec/joosy/extensions/resources/base_spec.coffee

@@ -51,21 +51,33 @@ describe "Joosy.Resources.Base", ->
     @resource 'another.deep.value', 'banana strikes back'
     expect(@resource 'another.deep').toEqual value: 'banana strikes back'
 
-  it "handles @at", ->
-    class Fluffy extends Joosy.Resources.Base
-      @entity 'fluffy'
+  describe '@at', ->
+    # clone won't be instanceof Fluffy in IE
+    #expect(clone.build({}) instanceof Fluffy).toBeTruthy()
 
-    clone = Fluffy.at('rumbas!')
+    beforeEach ->
+      class @Fluffy extends Joosy.Resources.Base
+        @entity 'fluffy'
 
-    expect(clone.__source).toEqual 'rumbas!'
-    expect(Joosy.Module.hasAncestor clone, Fluffy).toBeTruthy()
+    it 'returns base class child', ->
+      clone = @Fluffy.at 'rumbas'
+      expect(Joosy.Module.hasAncestor clone, @Fluffy).toBeTruthy()
 
-    clone = Fluffy.at Test.build(1)
+    it 'accepts string', ->
+      clone = @Fluffy.at 'rumbas'
+      expect(clone.__source).toEqual '/rumbas'
 
-    expect(clone.__source).toEqual '/tests/1/fluffies'
-    expect(Joosy.Module.hasAncestor clone, Fluffy).toBeTruthy()
-    # clone won't be instanceof Fluffy in IE
-    #expect(clone.build({}) instanceof Fluffy).toBeTruthy()
+    it 'accepts another resource instance', ->
+      clone = @Fluffy.at Test.build(1)
+      expect(clone.__source).toEqual '/tests/1/fluffies'
+
+    it 'accepts array', ->
+      clone = @Fluffy.at ['rumbas', Test.build(1), 'salsas']
+      expect(clone.__source).toEqual '/rumbas/tests/1/salsas'
+
+    it 'accepts sequential attributes', ->
+      clone = @Fluffy.at 'rumbas', 'salsas', Test.build(1)
+      expect(clone.__source).toEqual '/rumbas/salsas/tests/1/fluffies'
 
   it "triggers 'changed' right", ->
     callback = sinon.spy()