Skip to content

E
edx-platform
Commit c0c5e920 by cahrens
Options

Go back to setFixtures.

parent 2f504ec4
Showing with 292 additions and 291 deletions
cms/static/coffee/spec/main_spec.coffee
...@@ -27,7 +27,7 @@ describe "AJAX Errors", -> ...@@ -27,7 +27,7 @@ describe "AJAX Errors", ->
tpl = readFixtures('system-feedback.underscore') tpl = readFixtures('system-feedback.underscore')
beforeEach -> beforeEach ->
appendSetFixtures($("<script>", {id: "system-feedback-tpl", type: "text/template"}).text(tpl)) setFixtures($("<script>", {id: "system-feedback-tpl", type: "text/template"}).text(tpl))
appendSetFixtures(sandbox({id: "page-notification"})) appendSetFixtures(sandbox({id: "page-notification"}))
@requests = requests = [] @requests = requests = []
@xhr = sinon.useFakeXMLHttpRequest() @xhr = sinon.useFakeXMLHttpRequest()
......
cms/static/coffee/spec/views/feedback_spec.coffee
tpl = readFixtures('system-feedback.underscore') tpl = readFixtures('system-feedback.underscore')
beforeEach -> beforeEach ->
appendSetFixtures(sandbox({id: "page-alert"})) setFixtures(sandbox({id: "page-alert"}))
appendSetFixtures(sandbox({id: "page-notification"})) appendSetFixtures(sandbox({id: "page-notification"}))
appendSetFixtures(sandbox({id: "page-prompt"})) appendSetFixtures(sandbox({id: "page-prompt"}))
appendSetFixtures($("<script>", {id: "system-feedback-tpl", type: "text/template"}).text(tpl)) appendSetFixtures($("<script>", {id: "system-feedback-tpl", type: "text/template"}).text(tpl))
......
cms/static/coffee/spec/views/metadata_edit_spec.coffee
editorTemplate = readFixtures('metadata-editor.underscore') describe "Test Metadata Editor", ->
numberEntryTemplate = readFixtures('metadata-number-entry.underscore') editorTemplate = readFixtures('metadata-editor.underscore')
stringEntryTemplate = readFixtures('metadata-string-entry.underscore') numberEntryTemplate = readFixtures('metadata-number-entry.underscore')
optionEntryTemplate = readFixtures('metadata-option-entry.underscore') stringEntryTemplate = readFixtures('metadata-string-entry.underscore')
optionEntryTemplate = readFixtures('metadata-option-entry.underscore')
beforeEach ->
appendSetFixtures($("<script>", {id: "metadata-editor-tpl", type: "text/template"}).text(editorTemplate))
appendSetFixtures($("<script>", {id: "metadata-number-entry", type: "text/template"}).text(numberEntryTemplate))
appendSetFixtures($("<script>", {id: "metadata-string-entry", type: "text/template"}).text(stringEntryTemplate))
appendSetFixtures($("<script>", {id: "metadata-option-entry", type: "text/template"}).text(optionEntryTemplate))
genericEntry = {
default_value: 'default value',
display_name: "Display Name",
explicitly_set: true,
field_name: "display_name",
help: "Specifies the name for this component.",
inheritable: false,
options: [],
type: CMS.Models.Metadata.GENERIC_TYPE,
value: "Word cloud"
}
selectEntry = {
default_value: "answered",
display_name: "Show Answer",
explicitly_set: false,
field_name: "show_answer",
help: "When should you show the answer",
inheritable: true,
options: [
{"display_name": "Always", "value": "always"},
{"display_name": "Answered", "value": "answered"},
{"display_name": "Never", "value": "never"}
],
type: CMS.Models.Metadata.SELECT_TYPE,
value: "always"
}
integerEntry = {
default_value: 5,
display_name: "Inputs",
explicitly_set: false,
field_name: "num_inputs",
help: "Number of text boxes for student to input words/sentences.",
inheritable: false,
options: {min: 1},
type: CMS.Models.Metadata.INTEGER_TYPE,
value: 5
}
floatEntry = {
default_value: 2.7,
display_name: "Weight",
explicitly_set: true,
field_name: "weight",
help: "Weight for this problem",
inheritable: true,
options: {min: 1.3, max:100.2, step:0.1},
type: CMS.Models.Metadata.FLOAT_TYPE,
value: 10.2
}
# Test for the editor that creates the individual views.
describe "CMS.Views.Metadata.Editor creates editors for each field", ->
beforeEach -> beforeEach ->
@model = new Backbone.Model({ setFixtures($("<script>", {id: "metadata-editor-tpl", type: "text/template"}).text(editorTemplate))
num_inputs: integerEntry, appendSetFixtures($("<script>", {id: "metadata-number-entry", type: "text/template"}).text(numberEntryTemplate))
weight: floatEntry, appendSetFixtures($("<script>", {id: "metadata-string-entry", type: "text/template"}).text(stringEntryTemplate))
show_answer: selectEntry, appendSetFixtures($("<script>", {id: "metadata-option-entry", type: "text/template"}).text(optionEntryTemplate))
display_name: genericEntry,
unknown_type: { genericEntry = {
default_value: null, default_value: 'default value',
display_name: "Unknown", display_name: "Display Name",
explicitly_set: true, explicitly_set: true,
field_name: "unknown_type", field_name: "display_name",
help: "Mystery property.", help: "Specifies the name for this component.",
inheritable: false, inheritable: false,
options: [ options: [],
{"display_name": "Always", "value": "always"}, type: CMS.Models.Metadata.GENERIC_TYPE,
{"display_name": "Answered", "value": "answered"}, value: "Word cloud"
{"display_name": "Never", "value": "never"}], }
type: "unknown type",
value: null selectEntry = {
} default_value: "answered",
}) display_name: "Show Answer",
explicitly_set: false,
it "creates child views on initialize, and sorts them alphabetically", -> field_name: "show_answer",
view = new CMS.Views.Metadata.Editor({model: @model}) help: "When should you show the answer",
childModels = view.models inheritable: true,
expect(childModels.length).toBe(5) options: [
childViews = view.$el.find('.setting-input') {"display_name": "Always", "value": "always"},
expect(childViews.length).toBe(5) {"display_name": "Answered", "value": "answered"},
{"display_name": "Never", "value": "never"}
verifyEntry = (index, display_name, type) -> ],
expect(childModels[index].get('display_name')).toBe(display_name) type: CMS.Models.Metadata.SELECT_TYPE,
expect(childViews[index].type).toBe(type) value: "always"
}
verifyEntry(0, 'Display Name', 'text')
verifyEntry(1, 'Inputs', 'number') integerEntry = {
verifyEntry(2, 'Show Answer', 'select-one') default_value: 5,
verifyEntry(3, 'Unknown', 'text') display_name: "Inputs",
verifyEntry(4, 'Weight', 'number') explicitly_set: false,
field_name: "num_inputs",
it "returns its display name", -> help: "Number of text boxes for student to input words/sentences.",
view = new CMS.Views.Metadata.Editor({model: @model}) inheritable: false,
expect(view.getDisplayName()).toBe("Word cloud") options: {min: 1},
type: CMS.Models.Metadata.INTEGER_TYPE,
it "returns an empty string if there is no display name property with a valid value", -> value: 5
view = new CMS.Views.Metadata.Editor({model: new Backbone.Model()}) }
expect(view.getDisplayName()).toBe("")
floatEntry = {
view = new CMS.Views.Metadata.Editor({model: new Backbone.Model({ default_value: 2.7,
display_name: display_name: "Weight",
{ explicitly_set: true,
default_value: null, field_name: "weight",
display_name: "Display Name", help: "Weight for this problem",
explicitly_set: false, inheritable: true,
field_name: "display_name", options: {min: 1.3, max:100.2, step:0.1},
help: "", type: CMS.Models.Metadata.FLOAT_TYPE,
inheritable: false, value: 10.2
options: [], }
type: CMS.Models.Metadata.GENERIC_TYPE,
value: null # Test for the editor that creates the individual views.
describe "CMS.Views.Metadata.Editor creates editors for each field", ->
beforeEach ->
@model = new Backbone.Model({
num_inputs: integerEntry,
weight: floatEntry,
show_answer: selectEntry,
display_name: genericEntry,
unknown_type: {
default_value: null,
display_name: "Unknown",
explicitly_set: true,
field_name: "unknown_type",
help: "Mystery property.",
inheritable: false,
options: [
{"display_name": "Always", "value": "always"},
{"display_name": "Answered", "value": "answered"},
{"display_name": "Never", "value": "never"}],
type: "unknown type",
value: null
} }
}) })
})
expect(view.getDisplayName()).toBe("")
it "has no modified values by default", ->
view = new CMS.Views.Metadata.Editor({model: @model})
expect(view.getModifiedMetadataValues()).toEqual({})
it "returns modified values only", ->
view = new CMS.Views.Metadata.Editor({model: @model})
childModels = view.models
childModels[0].setValue('updated display name')
childModels[1].setValue(20)
expect(view.getModifiedMetadataValues()).toEqual({
display_name : 'updated display name',
num_inputs: 20
})
# Tests for individual views.
assertInputType = (view, expectedType) ->
input = view.$el.find('.setting-input')
expect(input.length).toBe(1)
expect(input[0].type).toBe(expectedType)
assertValueInView = (view, expectedValue) ->
expect(view.getValueFromEditor()).toBe(expectedValue)
assertCanUpdateView = (view, newValue) ->
view.setValueInEditor(newValue)
expect(view.getValueFromEditor()).toBe(newValue)
assertClear = (view, modelValue, editorValue=modelValue) ->
view.clear()
expect(view.model.getValue()).toBe(null)
expect(view.model.getDisplayValue()).toBe(modelValue)
expect(view.getValueFromEditor()).toBe(editorValue)
assertUpdateModel = (view, originalValue, newValue) ->
view.setValueInEditor(newValue)
expect(view.model.getValue()).toBe(originalValue)
view.updateModel()
expect(view.model.getValue()).toBe(newValue)
describe "CMS.Views.Metadata.String is a basic string input with clear functionality", ->
beforeEach ->
model = new CMS.Models.Metadata(genericEntry)
@view = new CMS.Views.Metadata.String({model: model})
it "uses a text input type", ->
assertInputType(@view, 'text')
it "returns the intial value upon initialization", ->
assertValueInView(@view, 'Word cloud')
it "can update its value in the view", ->
assertCanUpdateView(@view, "updated ' \" &")
it "has a clear method to revert to the model default", ->
assertClear(@view, 'default value')
it "has an update model method", -> it "creates child views on initialize, and sorts them alphabetically", ->
assertUpdateModel(@view, 'Word cloud', 'updated') view = new CMS.Views.Metadata.Editor({model: @model})
childModels = view.models
describe "CMS.Views.Metadata.Option is an option input type with clear functionality", -> expect(childModels.length).toBe(5)
beforeEach -> childViews = view.$el.find('.setting-input')
model = new CMS.Models.Metadata(selectEntry) expect(childViews.length).toBe(5)
@view = new CMS.Views.Metadata.Option({model: model})
verifyEntry = (index, display_name, type) ->
expect(childModels[index].get('display_name')).toBe(display_name)
expect(childViews[index].type).toBe(type)
verifyEntry(0, 'Display Name', 'text')
verifyEntry(1, 'Inputs', 'number')
verifyEntry(2, 'Show Answer', 'select-one')
verifyEntry(3, 'Unknown', 'text')
verifyEntry(4, 'Weight', 'number')
it "returns its display name", ->
view = new CMS.Views.Metadata.Editor({model: @model})
expect(view.getDisplayName()).toBe("Word cloud")
it "returns an empty string if there is no display name property with a valid value", ->
view = new CMS.Views.Metadata.Editor({model: new Backbone.Model()})
expect(view.getDisplayName()).toBe("")
view = new CMS.Views.Metadata.Editor({model: new Backbone.Model({
display_name:
{
default_value: null,
display_name: "Display Name",
explicitly_set: false,
field_name: "display_name",
help: "",
inheritable: false,
options: [],
type: CMS.Models.Metadata.GENERIC_TYPE,
value: null
}
})
})
expect(view.getDisplayName()).toBe("")
it "has no modified values by default", ->
view = new CMS.Views.Metadata.Editor({model: @model})
expect(view.getModifiedMetadataValues()).toEqual({})
it "returns modified values only", ->
view = new CMS.Views.Metadata.Editor({model: @model})
childModels = view.models
childModels[0].setValue('updated display name')
childModels[1].setValue(20)
expect(view.getModifiedMetadataValues()).toEqual({
display_name : 'updated display name',
num_inputs: 20
})
it "uses a select input type", -> # Tests for individual views.
assertInputType(@view, 'select-one') assertInputType = (view, expectedType) ->
input = view.$el.find('.setting-input')
expect(input.length).toBe(1)
expect(input[0].type).toBe(expectedType)
it "returns the intial value upon initialization", -> assertValueInView = (view, expectedValue) ->
assertValueInView(@view, 'always') expect(view.getValueFromEditor()).toBe(expectedValue)
it "can update its value in the view", -> assertCanUpdateView = (view, newValue) ->
assertCanUpdateView(@view, "never") view.setValueInEditor(newValue)
expect(view.getValueFromEditor()).toBe(newValue)
it "has a clear method to revert to the model default", -> assertClear = (view, modelValue, editorValue=modelValue) ->
assertClear(@view, 'answered') view.clear()
expect(view.model.getValue()).toBe(null)
expect(view.model.getDisplayValue()).toBe(modelValue)
expect(view.getValueFromEditor()).toBe(editorValue)
it "has an update model method", -> assertUpdateModel = (view, originalValue, newValue) ->
assertUpdateModel(@view, null, 'never') view.setValueInEditor(newValue)
expect(view.model.getValue()).toBe(originalValue)
view.updateModel()
expect(view.model.getValue()).toBe(newValue)
it "does not update to a value that is not an option", -> describe "CMS.Views.Metadata.String is a basic string input with clear functionality", ->
@view.setValueInEditor("not an option") beforeEach ->
expect(@view.getValueFromEditor()).toBe('always') model = new CMS.Models.Metadata(genericEntry)
@view = new CMS.Views.Metadata.String({model: model})
describe "CMS.Views.Metadata.Number supports integer or float type and has clear functionality", -> it "uses a text input type", ->
beforeEach -> assertInputType(@view, 'text')
integerModel = new CMS.Models.Metadata(integerEntry)
@integerView = new CMS.Views.Metadata.Number({model: integerModel}) it "returns the intial value upon initialization", ->
assertValueInView(@view, 'Word cloud')
floatModel = new CMS.Models.Metadata(floatEntry)
@floatView = new CMS.Views.Metadata.Number({model: floatModel}) it "can update its value in the view", ->
assertCanUpdateView(@view, "updated ' \" &")
it "uses a number input type", ->
assertInputType(@integerView, 'number') it "has a clear method to revert to the model default", ->
assertInputType(@floatView, 'number') assertClear(@view, 'default value')
it "returns the intial value upon initialization", -> it "has an update model method", ->
assertValueInView(@integerView, '5') assertUpdateModel(@view, 'Word cloud', 'updated')
assertValueInView(@floatView, '10.2')
describe "CMS.Views.Metadata.Option is an option input type with clear functionality", ->
it "can update its value in the view", -> beforeEach ->
assertCanUpdateView(@integerView, "12") model = new CMS.Models.Metadata(selectEntry)
assertCanUpdateView(@floatView, "-2.4") @view = new CMS.Views.Metadata.Option({model: model})
it "has a clear method to revert to the model default", -> it "uses a select input type", ->
assertClear(@integerView, 5, '5') assertInputType(@view, 'select-one')
assertClear(@floatView, 2.7, '2.7')
it "returns the intial value upon initialization", ->
it "has an update model method", -> assertValueInView(@view, 'always')
assertUpdateModel(@integerView, null, '90')
assertUpdateModel(@floatView, 10.2, '-9.5') it "can update its value in the view", ->
assertCanUpdateView(@view, "never")
it "knows the difference between integer and float", ->
expect(@integerView.isIntegerField()).toBeTruthy() it "has a clear method to revert to the model default", ->
expect(@floatView.isIntegerField()).toBeFalsy() assertClear(@view, 'answered')
it "sets attribtues related to min, max, and step", -> it "has an update model method", ->
verifyAttributes = (view, min, step, max=null) -> assertUpdateModel(@view, null, 'never')
inputEntry = view.$el.find('input')
expect(Number(inputEntry.attr('min'))).toEqual(min) it "does not update to a value that is not an option", ->
expect(Number(inputEntry.attr('step'))).toEqual(step) @view.setValueInEditor("not an option")
if max is not null expect(@view.getValueFromEditor()).toBe('always')
expect(Number(inputEntry.attr('max'))).toEqual(max)
describe "CMS.Views.Metadata.Number supports integer or float type and has clear functionality", ->
verifyAttributes(@integerView, 1, 1) beforeEach ->
verifyAttributes(@floatView, 1.3, .1, 100.2) integerModel = new CMS.Models.Metadata(integerEntry)
@integerView = new CMS.Views.Metadata.Number({model: integerModel})
it "corrects values that are out of range", ->
verifyValueAfterChanged = (view, value, expectedResult) -> floatModel = new CMS.Models.Metadata(floatEntry)
view.setValueInEditor(value) @floatView = new CMS.Views.Metadata.Number({model: floatModel})
view.changed()
expect(view.getValueFromEditor()).toBe(expectedResult) it "uses a number input type", ->
assertInputType(@integerView, 'number')
verifyValueAfterChanged(@integerView, '-4', '1') assertInputType(@floatView, 'number')
verifyValueAfterChanged(@integerView, '1', '1')
verifyValueAfterChanged(@integerView, '0', '1') it "returns the intial value upon initialization", ->
verifyValueAfterChanged(@integerView, '3001', '3001') assertValueInView(@integerView, '5')
assertValueInView(@floatView, '10.2')
verifyValueAfterChanged(@floatView, '-4', '1.3')
verifyValueAfterChanged(@floatView, '1.3', '1.3') it "can update its value in the view", ->
verifyValueAfterChanged(@floatView, '1.2', '1.3') assertCanUpdateView(@integerView, "12")
verifyValueAfterChanged(@floatView, '100.2', '100.2') assertCanUpdateView(@floatView, "-2.4")
verifyValueAfterChanged(@floatView, '100.3', '100.2')
it "has a clear method to revert to the model default", ->
it "disallows invalid characters", -> assertClear(@integerView, 5, '5')
verifyValueAfterKeyPressed = (view, character, reject) -> assertClear(@floatView, 2.7, '2.7')
event = {
type : 'keypress', it "has an update model method", ->
which : character.charCodeAt(0), assertUpdateModel(@integerView, null, '90')
keyCode: character.charCodeAt(0), assertUpdateModel(@floatView, 10.2, '-9.5')
preventDefault : () -> 'no op'
} it "knows the difference between integer and float", ->
spyOn(event, 'preventDefault') expect(@integerView.isIntegerField()).toBeTruthy()
view.$el.find('input').trigger(event) expect(@floatView.isIntegerField()).toBeFalsy()
if (reject)
expect(event.preventDefault).toHaveBeenCalled() it "sets attribtues related to min, max, and step", ->
else verifyAttributes = (view, min, step, max=null) ->
expect(event.preventDefault).not.toHaveBeenCalled() inputEntry = view.$el.find('input')
expect(Number(inputEntry.attr('min'))).toEqual(min)
verifyDisallowedChars = (view) -> expect(Number(inputEntry.attr('step'))).toEqual(step)
verifyValueAfterKeyPressed(view, 'a', true) if max is not null
verifyValueAfterKeyPressed(view, '.', view.isIntegerField()) expect(Number(inputEntry.attr('max'))).toEqual(max)
verifyValueAfterKeyPressed(view, '[', true)
verifyValueAfterKeyPressed(view, '@', true) verifyAttributes(@integerView, 1, 1)
verifyAttributes(@floatView, 1.3, .1, 100.2)
for i in [0...9]
verifyValueAfterKeyPressed(view, String(i), false) it "corrects values that are out of range", ->
verifyValueAfterChanged = (view, value, expectedResult) ->
verifyDisallowedChars(@integerView) view.setValueInEditor(value)
verifyDisallowedChars(@floatView) view.changed()
expect(view.getValueFromEditor()).toBe(expectedResult)
verifyValueAfterChanged(@integerView, '-4', '1')
verifyValueAfterChanged(@integerView, '1', '1')
verifyValueAfterChanged(@integerView, '0', '1')
verifyValueAfterChanged(@integerView, '3001', '3001')
verifyValueAfterChanged(@floatView, '-4', '1.3')
verifyValueAfterChanged(@floatView, '1.3', '1.3')
verifyValueAfterChanged(@floatView, '1.2', '1.3')
verifyValueAfterChanged(@floatView, '100.2', '100.2')
verifyValueAfterChanged(@floatView, '100.3', '100.2')
it "disallows invalid characters", ->
verifyValueAfterKeyPressed = (view, character, reject) ->
event = {
type : 'keypress',
which : character.charCodeAt(0),
keyCode: character.charCodeAt(0),
preventDefault : () -> 'no op'
}
spyOn(event, 'preventDefault')
view.$el.find('input').trigger(event)
if (reject)
expect(event.preventDefault).toHaveBeenCalled()
else
expect(event.preventDefault).not.toHaveBeenCalled()
verifyDisallowedChars = (view) ->
verifyValueAfterKeyPressed(view, 'a', true)
verifyValueAfterKeyPressed(view, '.', view.isIntegerField())
verifyValueAfterKeyPressed(view, '[', true)
verifyValueAfterKeyPressed(view, '@', true)
for i in [0...9]
verifyValueAfterKeyPressed(view, String(i), false)
verifyDisallowedChars(@integerView)
verifyDisallowedChars(@floatView)
cms/static/coffee/spec/views/module_edit_spec.coffee
...@@ -4,7 +4,7 @@ describe "CMS.Views.ModuleEdit", -> ...@@ -4,7 +4,7 @@ describe "CMS.Views.ModuleEdit", ->
@stubModule.id = 'stub-id' @stubModule.id = 'stub-id'
appendSetFixtures """ setFixtures """
<li class="component" id="stub-id"> <li class="component" id="stub-id">
<div class="component-editor"> <div class="component-editor">
<div class="module-editor"> <div class="module-editor">
......
cms/static/coffee/spec/views/section_spec.coffee
...@@ -29,7 +29,7 @@ describe "CMS.Views.SectionEdit", -> ...@@ -29,7 +29,7 @@ describe "CMS.Views.SectionEdit", ->
feedback_tpl = readFixtures('system-feedback.underscore') feedback_tpl = readFixtures('system-feedback.underscore')
beforeEach -> beforeEach ->
appendSetFixtures($("<script>", {id: "section-name-edit-tpl", type: "text/template"}).text(tpl)) setFixtures($("<script>", {id: "section-name-edit-tpl", type: "text/template"}).text(tpl))
appendSetFixtures($("<script>", {id: "system-feedback-tpl", type: "text/template"}).text(feedback_tpl)) appendSetFixtures($("<script>", {id: "system-feedback-tpl", type: "text/template"}).text(feedback_tpl))
spyOn(CMS.Views.SectionEdit.prototype, "switchToShowView") spyOn(CMS.Views.SectionEdit.prototype, "switchToShowView")
.andCallThrough() .andCallThrough()
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment