glenux-contrib/metamaps--metamaps
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #461 from metamaps/feature/rspec-tests

Browse source 
more rspec tests
This commit is contained in:
Devin Howard 2016-02-12 15:09:32 +08:00
commit 1be102467e
28 changed files with 322 additions and 578 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -19,6 +19,8 @@ vendor/
log/*.log
tmp
coverage
.DS_Store
*/.DS_Store
.DS_Store?

3
.simplecov Normal file
View file

@ -0,0 +1,3 @@
if ENV['COVERAGE'] == 'on'
SimpleCov.start 'rails'
end

2
Gemfile
View file

@ -42,6 +42,8 @@ group :test do
gem 'rspec-rails'
gem 'factory_girl_rails'
gem 'shoulda-matchers'
gem 'simplecov', require: false
gem 'json-schema'
end
group :production do #this is used on heroku

13
Gemfile.lock
View file

@ -36,6 +36,7 @@ GEM
minitest (~> 5.1)
thread_safe (~> 0.3, >= 0.3.4)
tzinfo (~> 1.1)
addressable (2.3.8)
arel (6.0.3)
aws-sdk (1.66.0)
aws-sdk-v1 (= 1.66.0)
@ -78,6 +79,7 @@ GEM
thread_safe (~> 0.1)
warden (~> 1.2.3)
diff-lcs (1.2.5)
docile (1.1.5)
dotenv (2.0.2)
erubis (2.7.0)
execjs (2.6.0)
@ -104,6 +106,8 @@ GEM
jquery-ui-rails (5.0.5)
railties (>= 3.2.16)
json (1.8.3)
json-schema (2.6.0)
addressable (~> 2.3.8)
kaminari (0.16.3)
actionpack (>= 3.0.0)
activesupport (>= 3.0.0)
@ -203,6 +207,11 @@ GEM
tilt (>= 1.1, < 3)
shoulda-matchers (3.0.1)
activesupport (>= 4.0.0)
simplecov (0.11.1)
docile (~> 1.1.0)
json (~> 1.8)
simplecov-html (~> 0.10.0)
simplecov-html (0.10.0)
slop (3.6.0)
sprockets (3.4.0)
rack (> 1, < 3)
@ -245,6 +254,7 @@ DEPENDENCIES
jquery-rails
jquery-ui-rails
json
json-schema
kaminari
paperclip
pg
@ -258,9 +268,10 @@ DEPENDENCIES
rspec-rails
sass-rails
shoulda-matchers
simplecov
tunemygc
uglifier
uservoice-ruby
BUNDLED WITH
1.10.6
1.11.2

6
app/controllers/mappings_controller.rb
View file

@ -15,8 +15,6 @@ class MappingsController < ApplicationController
def create
@mapping = Mapping.new(mapping_params)
@mapping.map.touch(:updated_at)
if @mapping.save
render json: @mapping, status: :created
else
@ -28,8 +26,6 @@ class MappingsController < ApplicationController
def update
@mapping = Mapping.find(params[:id])
@mapping.map.touch(:updated_at)
if @mapping.update_attributes(mapping_params)
head :no_content
else
@ -44,8 +40,6 @@ class MappingsController < ApplicationController
@mapping.destroy
@map.touch(:updated_at)
head :no_content
end

59
app/controllers/maps_controller.rb
View file

@ -1,5 +1,4 @@
class MapsController < ApplicationController
before_filter :require_user, only: [:create, :update, :screenshot, :destroy]
respond_to :html, :json
@ -10,38 +9,24 @@ class MapsController < ApplicationController
# GET /explore/featured
# GET /explore/mapper/:id
def index
if request.path == "/explore"
redirect_to activemaps_url and return
end
return redirect_to activemaps_url if request.path == "/explore"
@current = current_user
@user = nil
@maps = []
@mapperId = nil
if !params[:page]
page = 1
else
page = params[:page]
end
page = params[:page].present? ? params[:page] : 1
if request.path.index("/explore/active") != nil
@maps = Map.where("maps.permission != ?", "private").order("updated_at DESC").page(page).per(20)
@request = "active"
elsif request.path.index("/explore/featured") != nil
@maps = Map.where("maps.featured = ? AND maps.permission != ?", true, "private").order("updated_at DESC").page(page).per(20)
@request = "featured"
elsif request.path.index('/explore/mine') != nil # looking for maps by me
if !authenticated?
redirect_to activemaps_url and return
end
return redirect_to activemaps_url if !authenticated?
# don't need to exclude private maps because they all belong to you
@maps = Map.where("maps.user_id = ?", @current.id).order("updated_at DESC").page(page).per(20)
@request = "you"
elsif request.path.index('/explore/mapper/') != nil # looking for maps by a mapper
@user = User.find(params[:id])
@maps = Map.where("maps.user_id = ? AND maps.permission != ?", @user.id, "private").order("updated_at DESC").page(page).per(20)
@ -117,7 +102,6 @@ class MapsController < ApplicationController
# POST maps
def create
@user = current_user
@map = Map.new()
@map.name = params[:name]
@ -125,40 +109,45 @@ class MapsController < ApplicationController
@map.permission = params[:permission]
@map.user = @user
@map.arranged = false
@map.save
if params[:topicsToMap]
@all = params[:topicsToMap]
@all = @all.split(',')
@all.each do |topic|
topic = topic.split('/')
@mapping = Mapping.new()
@mapping.user = @user
@mapping.map = @map
@mapping.mappable = Topic.find(topic[0])
@mapping.xloc = topic[1]
@mapping.yloc = topic[2]
@mapping.save
mapping = Mapping.new()
mapping.user = @user
mapping.mappable = Topic.find(topic[0])
mapping.xloc = topic[1]
mapping.yloc = topic[2]
@map.topicmappings << mapping
mapping.save
end
if params[:synapsesToMap]
@synAll = params[:synapsesToMap]
@synAll = @synAll.split(',')
@synAll.each do |synapse_id|
@mapping = Mapping.new()
@mapping.user = @user
@mapping.map = @map
@mapping.mappable = Synapse.find(synapse_id)
@mapping.save
mapping = Mapping.new()
mapping.user = @user
mapping.map = @map
mapping.mappable = Synapse.find(synapse_id)
@map.synapsemappings << mapping
mapping.save
end
end
@map.arranged = true
@map.save
end
respond_to do |format|
if @map.save
respond_to do |format|
format.json { render :json => @map }
end
else
respond_to do |format|
format.json { render :json => "invalid params" }
end
end
end

42
app/controllers/metacodes_controller.rb
View file

@ -15,24 +15,12 @@ class MetacodesController < ApplicationController
redirect_to root_url, notice: "You need to be an admin for that."
return false
end
render action: "index"
render :index
}
format.json { render json: @metacodes }
end
end
### SHOW IS CURRENTLY DISABLED
# GET /metacodes/1
# GET /metacodes/1.json
# def show
# @metacode = Metacode.find(params[:id])
#
# respond_to do |format|
# format.html # show.html.erb
# format.json { render json: @metacode }
# end
# end
# GET /metacodes/new
# GET /metacodes/new.json
def new
@ -59,7 +47,7 @@ class MetacodesController < ApplicationController
format.html { redirect_to metacodes_url, notice: 'Metacode was successfully created.' }
format.json { render json: @metacode, status: :created, location: metacodes_url }
else
format.html { render action: "new" }
format.html { render :new }
format.json { render json: @metacode.errors, status: :unprocessable_entity }
end
end
@ -71,34 +59,20 @@ class MetacodesController < ApplicationController
@metacode = Metacode.find(params[:id])
respond_to do |format|
if @metacode.update_attributes(metacode_params)
if @metacode.update(metacode_params)
format.html { redirect_to metacodes_url, notice: 'Metacode was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.html { render :edit }
format.json { render json: @metacode.errors, status: :unprocessable_entity }
end
end
end
### DESTROY IS CURRENTLY DISABLED
# DELETE /metacodes/1
# DELETE /metacodes/1.json
# def destroy
# @metacode = Metacode.find(params[:id])
# @metacode.destroy
#
# respond_to do |format|
# format.html { redirect_to metacodes_url }
# format.json { head :no_content }
# end
# end
private
# Never trust parameters from the scary internet, only allow the white list through.
def metacode_params
params.require(:metacode).permit(:id, :name, :icon, :color)
end
# Never trust parameters from the scary internet, only allow the white list through.
def metacode_params
params.require(:metacode).permit(:id, :name, :icon, :color)
end
end

20
app/models/map.rb
View file

@ -41,41 +41,41 @@ class Map < ActiveRecord::Base
end
def topic_count
self.topics.length
topics.length
end
def synapse_count
self.synapses.length
synapses.length
end
def user_name
self.user.name
user.name
end
def user_image
self.user.image.url
user.image.url
end
def contributor_count
self.contributors.length
contributors.length
end
def screenshot_url
self.screenshot.url(:thumb)
screenshot.url(:thumb)
end
def created_at_str
self.created_at.strftime("%m/%d/%Y")
created_at.strftime("%m/%d/%Y")
end
def updated_at_str
self.updated_at.strftime("%m/%d/%Y")
updated_at.strftime("%m/%d/%Y")
end
def as_json(options={})
json = super(:methods =>[:user_name, :user_image, :topic_count, :synapse_count, :contributor_count, :screenshot_url], :except => [:screenshot_content_type, :screenshot_file_size, :screenshot_file_name, :screenshot_updated_at])
json[:created_at_clean] = self.created_at_str
json[:updated_at_clean] = self.updated_at_str
json[:created_at_clean] = created_at_str
json[:updated_at_clean] = updated_at_str
json
end

9
app/models/mapping.rb
View file

@ -4,10 +4,13 @@ class Mapping < ActiveRecord::Base
scope :synapsemapping, -> { where(mappable_type: :Synapse) }
belongs_to :mappable, polymorphic: true
belongs_to :map, :class_name => "Map", :foreign_key => "map_id"
belongs_to :map, :class_name => "Map", :foreign_key => "map_id", touch: true
belongs_to :user
validates :xloc, presence: true
validates :yloc, presence: true
validates :map, presence: true
validates :mappable, presence: true
def user_name
self.user.name

1
app/models/metacode.rb
View file

@ -1,5 +1,4 @@
class Metacode < ActiveRecord::Base
has_many :in_metacode_sets
has_many :metacode_sets, :through => :in_metacode_sets
has_many :topics

13
app/models/synapse.rb
View file

@ -1,5 +1,4 @@
class Synapse < ActiveRecord::Base
belongs_to :user
belongs_to :topic1, :class_name => "Topic", :foreign_key => "node1_id"
@ -13,17 +12,25 @@ class Synapse < ActiveRecord::Base
validates :permission, presence: true
validates :permission, inclusion: { in: Perm::ISSIONS.map(&:to_s) }
validates :category, inclusion: { in: ['from-to', 'both'], allow_nil: true }
# :nocov:
def user_name
self.user.name
user.name
end
# :nocov:
# :nocov:
def user_image
self.user.image.url
user.image.url
end
# :nocov:
# :nocov:
def as_json(options={})
super(:methods =>[:user_name, :user_image])
end
# :nocov:
##### PERMISSIONS ######

7
bin/jenkins-test.sh
View file

@ -1,7 +1,8 @@
#!/bin/bash -l
#prerequisites
#sudo aptitude -q -y install libpq-dev
# jenkins machine prerequisites
# sudo aptitude -q -y install libpq-dev
# install rvm with user gemsets
source "$HOME/.rvm/scripts/rvm"
rvm use $(cat .ruby-version) || \
@ -21,4 +22,4 @@ sed -i -e "s/DB_USERNAME='.*'/DB_USERNAME='jenkins'/" .env
#test
bundle install
rake db:create db:test:prepare
bundle exec rspec
COVERAGE=on bundle exec rspec

114
spec/controllers/mappings_controller_spec.rb
View file

@ -1,60 +1,16 @@
require 'rails_helper'
# This spec was generated by rspec-rails when you ran the scaffold generator.
# It demonstrates how one might use RSpec to specify the controller code that
# was generated by Rails when you ran the scaffold generator.
#
# It assumes that the implementation code is generated by the rails scaffold
# generator. If you are using any extension libraries to generate different
# controller code, this generated spec may or may not pass.
#
# It only uses APIs available in rails and/or rspec-rails. There are a number
# of tools you can use to make these specs even more expressive, but we're
# sticking to rails and rspec-rails APIs to keep things simple and stable.
#
# Compared to earlier versions of this generator, there is very limited use of
# stubs and message expectations in this spec. Stubs are only used when there
# is no simpler way to get a handle on the object needed for the example.
# Message expectations are only used when there is no simpler way to specify
# that an instance is receiving a specific message.
RSpec.describe MappingsController, type: :controller do
# This should return the minimal set of attributes required to create a valid
# Mapping. As you add validations to Mapping, be sure to
# adjust the attributes here as well.
let(:valid_attributes) do
skip('Add a hash of attributes valid for your model')
end
let(:invalid_attributes) do
skip('Add a hash of attributes invalid for your model')
end
# This should return the minimal set of values that should be in the session
# in order to pass any filters (e.g. authentication) defined in
# MappingsController. Be sure to keep this updated too.
let(:valid_session) { {} }
describe 'GET #index' do
it 'assigns all mappings as @mappings' do
mapping = Mapping.create! valid_attributes
get :index, {}, valid_session
expect(assigns(:mappings)).to eq([mapping])
end
let!(:mapping) { create(:mapping) }
let(:valid_attributes) { mapping.attributes.except('id') }
let(:invalid_attributes) { { xloc: 0 } }
before :each do
sign_in
end
describe 'GET #show' do
it 'assigns the requested mapping as @mapping' do
mapping = Mapping.create! valid_attributes
get :show, { id: mapping.to_param }, valid_session
expect(assigns(:mapping)).to eq(mapping)
end
end
describe 'GET #edit' do
it 'assigns the requested mapping as @mapping' do
mapping = Mapping.create! valid_attributes
get :edit, { id: mapping.to_param }, valid_session
get :show, { id: mapping.to_param }
expect(assigns(:mapping)).to eq(mapping)
end
end
@ -63,98 +19,56 @@ RSpec.describe MappingsController, type: :controller do
context 'with valid params' do
it 'creates a new Mapping' do
expect do
post :create, { mapping: valid_attributes }, valid_session
post :create, { mapping: valid_attributes }
end.to change(Mapping, :count).by(1)
end
it 'assigns a newly created mapping as @mapping' do
post :create, { mapping: valid_attributes }, valid_session
post :create, { mapping: valid_attributes }
expect(assigns(:mapping)).to be_a(Mapping)
expect(assigns(:mapping)).to be_persisted
end
it 'redirects to the created mapping' do
post :create, { mapping: valid_attributes }, valid_session
expect(response).to redirect_to(Mapping.last)
end
end
context 'with invalid params' do
it 'assigns a newly created but unsaved mapping as @mapping' do
post :create, { mapping: invalid_attributes }, valid_session
post :create, { mapping: invalid_attributes }
expect(assigns(:mapping)).to be_a_new(Mapping)
end
it "re-renders the 'new' template" do
post :create, { mapping: invalid_attributes }, valid_session
expect(response).to render_template('new')
end
end
end
describe 'PUT #update' do
context 'with valid params' do
let(:new_attributes) do
skip('Add a hash of attributes valid for your model')
end
let(:new_attributes) { build(:mapping_random_location).attributes.except('id') }
it 'updates the requested mapping' do
mapping = Mapping.create! valid_attributes
put :update,
{ id: mapping.to_param, mapping: new_attributes },
valid_session
{ id: mapping.to_param, mapping: new_attributes }
mapping.reload
skip('Add assertions for updated state')
end
it 'assigns the requested mapping as @mapping' do
mapping = Mapping.create! valid_attributes
put :update,
{ id: mapping.to_param, mapping: valid_attributes },
valid_session
{ id: mapping.to_param, mapping: valid_attributes }
expect(assigns(:mapping)).to eq(mapping)
end
it 'redirects to the mapping' do
mapping = Mapping.create! valid_attributes
put :update,
{ id: mapping.to_param, mapping: valid_attributes },
valid_session
expect(response).to redirect_to(mapping)
end
end
context 'with invalid params' do
it 'assigns the mapping as @mapping' do
mapping = Mapping.create! valid_attributes
put :update,
{ id: mapping.to_param, mapping: invalid_attributes },
valid_session
{ id: mapping.to_param, mapping: invalid_attributes }
expect(assigns(:mapping)).to eq(mapping)
end
it "re-renders the 'edit' template" do
mapping = Mapping.create! valid_attributes
put :update,
{ id: mapping.to_param, mapping: invalid_attributes },
valid_session
expect(response).to render_template('edit')
end
end
end
describe 'DELETE #destroy' do
it 'destroys the requested mapping' do
mapping = Mapping.create! valid_attributes
expect do
delete :destroy, { id: mapping.to_param }, valid_session
delete :destroy, { id: mapping.to_param }
end.to change(Mapping, :count).by(-1)
end
it 'redirects to the mappings list' do
mapping = Mapping.create! valid_attributes
delete :destroy, { id: mapping.to_param }, valid_session
expect(response).to redirect_to(mappings_url)
end
end
end

135
spec/controllers/maps_controller_spec.rb
View file

@ -1,60 +1,30 @@
require 'rails_helper'
# This spec was generated by rspec-rails when you ran the scaffold generator.
# It demonstrates how one might use RSpec to specify the controller code that
# was generated by Rails when you ran the scaffold generator.
#
# It assumes that the implementation code is generated by the rails scaffold
# generator. If you are using any extension libraries to generate different
# controller code, this generated spec may or may not pass.
#
# It only uses APIs available in rails and/or rspec-rails. There are a number
# of tools you can use to make these specs even more expressive, but we're
# sticking to rails and rspec-rails APIs to keep things simple and stable.
#
# Compared to earlier versions of this generator, there is very limited use of
# stubs and message expectations in this spec. Stubs are only used when there
# is no simpler way to get a handle on the object needed for the example.
# Message expectations are only used when there is no simpler way to specify
# that an instance is receiving a specific message.
RSpec.describe MapsController, type: :controller do
# This should return the minimal set of attributes required to create a valid
# Map. As you add validations to Map, be sure to
# adjust the attributes here as well.
let(:valid_attributes) do
skip('Add a hash of attributes valid for your model')
let(:map) { create(:map) }
let(:valid_attributes) { map.attributes.except(:id) }
let(:invalid_attributes) { { permission: :commons } }
before :each do
sign_in
end
let(:invalid_attributes) do
skip('Add a hash of attributes invalid for your model')
end
# This should return the minimal set of values that should be in the session
# in order to pass any filters (e.g. authentication) defined in
# MapsController. Be sure to keep this updated too.
let(:valid_session) { {} }
describe 'GET #index' do
it 'assigns all maps as @maps' do
map = Map.create! valid_attributes
get :index, {}, valid_session
it 'viewable maps as @maps' do
get :index, {}
expect(assigns(:maps)).to eq([map])
end
end
describe 'GET #contains' do
it 'returns json matching schema' do
get :contains, { id: map.to_param, format: :json }
expect(response.body).to match_json_schema(:map_contains)
end
end
describe 'GET #show' do
it 'assigns the requested map as @map' do
map = Map.create! valid_attributes
get :show, { id: map.to_param }, valid_session
expect(assigns(:map)).to eq(map)
end
end
describe 'GET #edit' do
it 'assigns the requested map as @map' do
map = Map.create! valid_attributes
get :edit, { id: map.to_param }, valid_session
get :show, { id: map.to_param }
expect(assigns(:map)).to eq(map)
end
end
@ -62,99 +32,72 @@ RSpec.describe MapsController, type: :controller do
describe 'POST #create' do
context 'with valid params' do
it 'creates a new Map' do
map.reload
expect do
post :create, { map: valid_attributes }, valid_session
post :create, valid_attributes.merge(format: :json)
end.to change(Map, :count).by(1)
end
it 'assigns a newly created map as @map' do
post :create, { map: valid_attributes }, valid_session
post :create, valid_attributes.merge(format: :json)
expect(assigns(:map)).to be_a(Map)
expect(assigns(:map)).to be_persisted
end
it 'redirects to the created map' do
post :create, { map: valid_attributes }, valid_session
expect(response).to redirect_to(Map.last)
end
end
context 'with invalid params' do
it 'assigns a newly created but unsaved map as @map' do
post :create, { map: invalid_attributes }, valid_session
post :create, invalid_attributes.merge(format: :json)
expect(assigns(:map)).to be_a_new(Map)
end
it "re-renders the 'new' template" do
post :create, { map: invalid_attributes }, valid_session
expect(response).to render_template('new')
end
end
end
describe 'PUT #update' do
context 'with valid params' do
let(:new_attributes) do
skip('Add a hash of attributes valid for your model')
end
let(:new_attributes) { { name: "Uncool map", permission: :private } }
it 'updates the requested map' do
map = Map.create! valid_attributes
put :update,
{ id: map.to_param, map: new_attributes },
valid_session
map.reload
skip('Add assertions for updated state')
{ id: map.to_param, map: new_attributes, format: :json }
expect(assigns(:map).name).to eq "Uncool map"
expect(assigns(:map).permission).to eq 'private'
end
it 'assigns the requested map as @map' do
map = Map.create! valid_attributes
put :update,
{ id: map.to_param, map: valid_attributes },
valid_session
{ id: map.to_param, map: valid_attributes, format: :json }
expect(assigns(:map)).to eq(map)
end
it 'redirects to the map' do
map = Map.create! valid_attributes
put :update,
{ id: map.to_param, map: valid_attributes },
valid_session
expect(response).to redirect_to(map)
end
end
context 'with invalid params' do
it 'assigns the map as @map' do
map = Map.create! valid_attributes
put :update,
{ id: map.to_param, map: invalid_attributes },
valid_session
{ id: map.to_param, map: invalid_attributes, format: :json }
expect(assigns(:map)).to eq(map)
end
it "re-renders the 'edit' template" do
map = Map.create! valid_attributes
put :update,
{ id: map.to_param, map: invalid_attributes },
valid_session
expect(response).to render_template('edit')
end
end
end
describe 'DELETE #destroy' do
it 'destroys the requested map' do
map = Map.create! valid_attributes
let(:unowned_map) { create(:map) }
let(:owned_map) { create(:map, user: controller.current_user) }
it 'prevents deletion by non-owners' do
unowned_map.reload
expect do
delete :destroy, { id: map.to_param }, valid_session
end.to change(Map, :count).by(-1)
delete :destroy, { id: unowned_map.to_param, format: :json }
end.to change(Map, :count).by(0)
expect(response.body).to eq("unauthorized")
end
it 'redirects to the maps list' do
map = Map.create! valid_attributes
delete :destroy, { id: map.to_param }, valid_session
expect(response).to redirect_to(maps_url)
it 'deletes owned map' do
owned_map.reload # ensure it's in the database
expect do
delete :destroy, { id: owned_map.to_param, format: :json }
end.to change(Map, :count).by(-1)
expect(response.body).to eq("success")
end
end
end

149
spec/controllers/metacodes_controller_spec.rb
View file

@ -1,72 +1,30 @@
require 'rails_helper'
# This spec was generated by rspec-rails when you ran the scaffold generator.
# It demonstrates how one might use RSpec to specify the controller code that
# was generated by Rails when you ran the scaffold generator.
#
# It assumes that the implementation code is generated by the rails scaffold
# generator. If you are using any extension libraries to generate different
# controller code, this generated spec may or may not pass.
#
# It only uses APIs available in rails and/or rspec-rails. There are a number
# of tools you can use to make these specs even more expressive, but we're
# sticking to rails and rspec-rails APIs to keep things simple and stable.
#
# Compared to earlier versions of this generator, there is very limited use of
# stubs and message expectations in this spec. Stubs are only used when there
# is no simpler way to get a handle on the object needed for the example.
# Message expectations are only used when there is no simpler way to specify
# that an instance is receiving a specific message.
RSpec.describe MetacodesController, type: :controller do
let(:metacode) { create(:metacode) }
let(:valid_attributes) { metacode.attributes.except('id') }
before :each do
@user = create(:user, admin: true)
sign_in @user
sign_in create(:user, admin: true)
end
# This should return the minimal set of attributes required to create a valid
# Metacode. As you add validations to Metacode, be sure to
# adjust the attributes here as well.
let(:valid_attributes) do
skip('Add a hash of attributes valid for your model')
end
let(:invalid_attributes) do
skip('Add a hash of attributes invalid for your model')
end
# This should return the minimal set of values that should be in the session
# in order to pass any filters (e.g. authentication) defined in
# MetacodesController. Be sure to keep this updated too.
let(:valid_session) { {} }
describe 'GET #index' do
it 'assigns all metacodes as @metacodes' do
metacode = Metacode.create! valid_attributes
get :index, {}, valid_session
expect(assigns(:metacodes)).to eq([metacode])
end
end
describe 'GET #show' do
it 'assigns the requested metacode as @metacode' do
metacode = Metacode.create! valid_attributes
get :show, { id: metacode.to_param }, valid_session
expect(assigns(:metacode)).to eq(metacode)
metacode.reload # ensure it's created
get :index, {}
expect(Metacode.all.to_a).to eq([metacode])
end
end
describe 'GET #new' do
it 'assigns a new metacode as @metacode' do
get :new, {}, valid_session
get :new, { format: :json }
expect(assigns(:metacode)).to be_a_new(Metacode)
end
end
describe 'GET #edit' do
it 'assigns the requested metacode as @metacode' do
metacode = Metacode.create! valid_attributes
get :edit, { id: metacode.to_param }, valid_session
get :edit, { id: metacode.to_param }
expect(assigns(:metacode)).to eq(metacode)
end
end
@ -74,32 +32,22 @@ RSpec.describe MetacodesController, type: :controller do
describe 'POST #create' do
context 'with valid params' do
it 'creates a new Metacode' do
metacode.reload # ensure it's present to start
expect do
post :create, { metacode: valid_attributes }, valid_session
post :create, { metacode: valid_attributes }
end.to change(Metacode, :count).by(1)
end
it 'assigns a newly created metacode as @metacode' do
post :create, { metacode: valid_attributes }, valid_session
it 'has the correct attributes' do
post :create, { metacode: valid_attributes }
# expect(Metacode.last.attributes.expect(:id)).to eq(metacode.attributes.except(:id))
expect(assigns(:metacode)).to be_a(Metacode)
expect(assigns(:metacode)).to be_persisted
end
it 'redirects to the created metacode' do
post :create, { metacode: valid_attributes }, valid_session
expect(response).to redirect_to(Metacode.last)
end
end
context 'with invalid params' do
it 'assigns a newly created but unsaved metacode as @metacode' do
post :create, { metacode: invalid_attributes }, valid_session
expect(assigns(:metacode)).to be_a_new(Metacode)
end
it "re-renders the 'new' template" do
post :create, { metacode: invalid_attributes }, valid_session
expect(response).to render_template('new')
it 'redirects to the metacode index' do
post :create, { metacode: valid_attributes }
expect(response).to redirect_to(metacodes_url)
end
end
end
@ -107,66 +55,33 @@ RSpec.describe MetacodesController, type: :controller do
describe 'PUT #update' do
context 'with valid params' do
let(:new_attributes) do
skip('Add a hash of attributes valid for your model')
{ icon: 'https://newimages.ca/cool-image.jpg',
color: '#ffffff',
name: 'Cognition' }
end
it 'updates the requested metacode' do
metacode = Metacode.create! valid_attributes
put :update,
{ id: metacode.to_param, metacode: new_attributes },
valid_session
{ id: metacode.to_param, metacode: new_attributes }
metacode.reload
skip('Add assertions for updated state')
end
it 'assigns the requested metacode as @metacode' do
metacode = Metacode.create! valid_attributes
put :update,
{ id: metacode.to_param, metacode: valid_attributes },
valid_session
expect(assigns(:metacode)).to eq(metacode)
end
it 'redirects to the metacode' do
metacode = Metacode.create! valid_attributes
put :update,
{ id: metacode.to_param, metacode: valid_attributes },
valid_session
expect(response).to redirect_to(metacode)
end
end
context 'with invalid params' do
it 'assigns the metacode as @metacode' do
metacode = Metacode.create! valid_attributes
put :update,
{ id: metacode.to_param, metacode: invalid_attributes },
valid_session
expect(assigns(:metacode)).to eq(metacode)
end
it "re-renders the 'edit' template" do
metacode = Metacode.create! valid_attributes
put :update,
{ id: metacode.to_param, metacode: invalid_attributes },
valid_session
expect(response).to render_template('edit')
expect(metacode.icon).to eq 'https://newimages.ca/cool-image.jpg'
expect(metacode.color).to eq '#ffffff'
expect(metacode.name).to eq 'Cognition'
end
end
end
describe 'DELETE #destroy' do
it 'destroys the requested metacode' do
metacode = Metacode.create! valid_attributes
expect do
delete :destroy, { id: metacode.to_param }, valid_session
end.to change(Metacode, :count).by(-1)
context 'not admin' do
it 'denies access to create' do
sign_in create(:user, admin: false)
post :create, { metacode: valid_attributes }
expect(response).to redirect_to root_url
end
it 'redirects to the metacodes list' do
metacode = Metacode.create! valid_attributes
delete :destroy, { id: metacode.to_param }, valid_session
expect(response).to redirect_to(metacodes_url)
it 'denies access to update' do
sign_in create(:user, admin: false)
post :update, { id: metacode.to_param, metacode: valid_attributes }
expect(response).to redirect_to root_url
end
end
end

131
spec/controllers/synapses_controller_spec.rb
View file

@ -1,60 +1,16 @@
require 'rails_helper'
# This spec was generated by rspec-rails when you ran the scaffold generator.
# It demonstrates how one might use RSpec to specify the controller code that
# was generated by Rails when you ran the scaffold generator.
#
# It assumes that the implementation code is generated by the rails scaffold
# generator. If you are using any extension libraries to generate different
# controller code, this generated spec may or may not pass.
#
# It only uses APIs available in rails and/or rspec-rails. There are a number
# of tools you can use to make these specs even more expressive, but we're
# sticking to rails and rspec-rails APIs to keep things simple and stable.
#
# Compared to earlier versions of this generator, there is very limited use of
# stubs and message expectations in this spec. Stubs are only used when there
# is no simpler way to get a handle on the object needed for the example.
# Message expectations are only used when there is no simpler way to specify
# that an instance is receiving a specific message.
RSpec.describe SynapsesController, type: :controller do
# This should return the minimal set of attributes required to create a valid
# Synapse. As you add validations to Synapse, be sure to
# adjust the attributes here as well.
let(:valid_attributes) do
skip('Add a hash of attributes valid for your model')
end
let(:invalid_attributes) do
skip('Add a hash of attributes invalid for your model')
end
# This should return the minimal set of values that should be in the session
# in order to pass any filters (e.g. authentication) defined in
# SynapsesController. Be sure to keep this updated too.
let(:valid_session) { {} }
describe 'GET #index' do
it 'assigns all synapses as @synapses' do
synapse = Synapse.create! valid_attributes
get :index, {}, valid_session
expect(assigns(:synapses)).to eq([synapse])
end
let(:synapse) { create(:synapse) }
let(:valid_attributes) { synapse.attributes.except('id') }
let(:invalid_attributes) { { permission: :invalid_lol } }
before :each do
sign_in
end
describe 'GET #show' do
it 'assigns the requested synapse as @synapse' do
synapse = Synapse.create! valid_attributes
get :show, { id: synapse.to_param }, valid_session
expect(assigns(:synapse)).to eq(synapse)
end
end
describe 'GET #edit' do
it 'assigns the requested synapse as @synapse' do
synapse = Synapse.create! valid_attributes
get :edit, { id: synapse.to_param }, valid_session
get :show, { id: synapse.to_param, format: :json }
expect(assigns(:synapse)).to eq(synapse)
end
end
@ -62,32 +18,28 @@ RSpec.describe SynapsesController, type: :controller do
describe 'POST #create' do
context 'with valid params' do
it 'creates a new Synapse' do
synapse.reload # ensure it's present
expect do
post :create, { synapse: valid_attributes }, valid_session
post :create, { synapse: valid_attributes, format: :json }
end.to change(Synapse, :count).by(1)
end
it 'assigns a newly created synapse as @synapse' do
post :create, { synapse: valid_attributes }, valid_session
post :create, { synapse: valid_attributes, format: :json }
expect(assigns(:synapse)).to be_a(Synapse)
expect(assigns(:synapse)).to be_persisted
end
it 'redirects to the created synapse' do
post :create, { synapse: valid_attributes }, valid_session
expect(response).to redirect_to(Synapse.last)
it 'returns 201 CREATED' do
post :create, { synapse: valid_attributes, format: :json }
expect(response.status).to eq 201
end
end
context 'with invalid params' do
it 'assigns a newly created but unsaved synapse as @synapse' do
post :create, { synapse: invalid_attributes }, valid_session
expect(assigns(:synapse)).to be_a_new(Synapse)
end
it "re-renders the 'new' template" do
post :create, { synapse: invalid_attributes }, valid_session
expect(response).to render_template('new')
it 'returns 422 UNPROCESSABLE ENTITY' do
post :create, { synapse: invalid_attributes, format: :json }
expect(response.status).to eq 422
end
end
end
@ -95,66 +47,49 @@ RSpec.describe SynapsesController, type: :controller do
describe 'PUT #update' do
context 'with valid params' do
let(:new_attributes) do
skip('Add a hash of attributes valid for your model')
{ desc: 'My new description',
category: 'both',
permission: :public }
end
it 'updates the requested synapse' do
synapse = Synapse.create! valid_attributes
put :update,
{ id: synapse.to_param, synapse: new_attributes },
valid_session
{ id: synapse.to_param, synapse: new_attributes, format: :json }
synapse.reload
skip('Add assertions for updated state')
expect(synapse.desc).to eq 'My new description'
expect(synapse.category).to eq 'both'
expect(synapse.permission).to eq 'public'
end
it 'assigns the requested synapse as @synapse' do
synapse = Synapse.create! valid_attributes
it 'returns 204 NO CONTENT' do
put :update,
{ id: synapse.to_param, synapse: valid_attributes },
valid_session
expect(assigns(:synapse)).to eq(synapse)
end
it 'redirects to the synapse' do
synapse = Synapse.create! valid_attributes
put :update,
{ id: synapse.to_param, synapse: valid_attributes },
valid_session
expect(response).to redirect_to(synapse)
{ id: synapse.to_param, synapse: valid_attributes, format: :json }
expect(response.status).to eq 204
end
end
context 'with invalid params' do
it 'assigns the synapse as @synapse' do
synapse = Synapse.create! valid_attributes
put :update,
{ id: synapse.to_param, synapse: invalid_attributes },
valid_session
{ id: synapse.to_param, synapse: invalid_attributes, format: :json }
expect(assigns(:synapse)).to eq(synapse)
end
it "re-renders the 'edit' template" do
synapse = Synapse.create! valid_attributes
put :update,
{ id: synapse.to_param, synapse: invalid_attributes },
valid_session
expect(response).to render_template('edit')
end
end
end
describe 'DELETE #destroy' do
let(:synapse) { create(:synapse, user: controller.current_user) }
it 'destroys the requested synapse' do
synapse = Synapse.create! valid_attributes
synapse.reload # ensure it's present
expect do
delete :destroy, { id: synapse.to_param }, valid_session
delete :destroy, { id: synapse.to_param, format: :json }
end.to change(Synapse, :count).by(-1)
end
it 'redirects to the synapses list' do
synapse = Synapse.create! valid_attributes
delete :destroy, { id: synapse.to_param }, valid_session
expect(response).to redirect_to(synapses_url)
it 'returns 204 NO CONTENT' do
delete :destroy, { id: synapse.to_param, format: :json }
expect(response.status).to eq 204
end
end
end

100
spec/controllers/topics_controller_spec.rb
View file

@ -1,36 +1,16 @@
require 'rails_helper'
RSpec.describe TopicsController, type: :controller do
let(:valid_attributes) do
skip('Add a hash of attributes valid for your model')
end
let(:invalid_attributes) do
skip('Add a hash of attributes invalid for your model')
end
let(:valid_session) { {} }
describe 'GET #index' do
it 'assigns all topics as @topics' do
topic = Topic.create! valid_attributes
get :index, {}, valid_session
expect(assigns(:topics)).to eq([topic])
end
let(:topic) { create(:topic) }
let(:valid_attributes) { topic.attributes.except('id') }
let(:invalid_attributes) { { permission: :invalid_lol } }
before :each do
sign_in
end
describe 'GET #show' do
it 'assigns the requested topic as @topic' do
topic = Topic.create! valid_attributes
get :show, { id: topic.to_param }, valid_session
expect(assigns(:topic)).to eq(topic)
end
end
describe 'GET #edit' do
it 'assigns the requested topic as @topic' do
topic = Topic.create! valid_attributes
get :edit, { id: topic.to_param }, valid_session
get :show, { id: topic.to_param, format: :json }
expect(assigns(:topic)).to eq(topic)
end
end
@ -38,99 +18,85 @@ RSpec.describe TopicsController, type: :controller do
describe 'POST #create' do
context 'with valid params' do
it 'creates a new Topic' do
topic.reload # ensure it's created
expect do
post :create, { topic: valid_attributes }, valid_session
post :create, { topic: valid_attributes, format: :json }
end.to change(Topic, :count).by(1)
end
it 'assigns a newly created topic as @topic' do
post :create, { topic: valid_attributes }, valid_session
post :create, { topic: valid_attributes, format: :json }
expect(assigns(:topic)).to be_a(Topic)
expect(assigns(:topic)).to be_persisted
end
it 'redirects to the created topic' do
post :create, { topic: valid_attributes }, valid_session
expect(response).to redirect_to(Topic.last)
it 'returns 201 CREATED' do
post :create, { topic: valid_attributes, format: :json }
expect(response.status).to eq 201
end
end
context 'with invalid params' do
it 'assigns a newly created but unsaved topic as @topic' do
post :create, { topic: invalid_attributes }, valid_session
post :create, { topic: invalid_attributes, format: :json }
expect(assigns(:topic)).to be_a_new(Topic)
end
it "re-renders the 'new' template" do
post :create, { topic: invalid_attributes }, valid_session
expect(response).to render_template('new')
end
end
end
describe 'PUT #update' do
context 'with valid params' do
let(:new_attributes) do
skip('Add a hash of attributes valid for your model')
{ name: 'Cool Topic with no number',
desc: 'This is a cool topic.',
link: 'https://cool-topics.com/4',
permission: :public }
end
it 'updates the requested topic' do
topic = Topic.create! valid_attributes
put :update,
{ id: topic.to_param, topic: new_attributes },
valid_session
{ id: topic.to_param, topic: new_attributes, format: :json }
topic.reload
skip('Add assertions for updated state')
expect(topic.name).to eq 'Cool Topic with no number'
expect(topic.desc).to eq 'This is a cool topic.'
expect(topic.link).to eq 'https://cool-topics.com/4'
expect(topic.permission).to eq 'public'
end
it 'assigns the requested topic as @topic' do
topic = Topic.create! valid_attributes
put :update,
{ id: topic.to_param, topic: valid_attributes },
valid_session
{ id: topic.to_param, topic: valid_attributes, format: :json }
expect(assigns(:topic)).to eq(topic)
end
it 'redirects to the topic' do
topic = Topic.create! valid_attributes
it 'returns status of no content' do
put :update,
{ id: topic.to_param, topic: valid_attributes },
valid_session
expect(response).to redirect_to(topic)
{ id: topic.to_param, topic: valid_attributes, format: :json }
expect(response.status).to eq 204
end
end
context 'with invalid params' do
it 'assigns the topic as @topic' do
topic = Topic.create! valid_attributes
put :update,
{ id: topic.to_param, topic: invalid_attributes },
valid_session
{ id: topic.to_param, topic: invalid_attributes, format: :json }
expect(assigns(:topic)).to eq(topic)
end
it "re-renders the 'edit' template" do
topic = Topic.create! valid_attributes
put :update,
{ id: topic.to_param, topic: invalid_attributes },
valid_session
expect(response).to render_template('edit')
end
end
end
describe 'DELETE #destroy' do
let(:owned_topic) { create(:topic, user: controller.current_user) }
it 'destroys the requested topic' do
topic = Topic.create! valid_attributes
owned_topic.reload # ensure it's there
expect do
delete :destroy, { id: topic.to_param }, valid_session
delete :destroy, { id: owned_topic.to_param, format: :json }
end.to change(Topic, :count).by(-1)
end
it 'redirects to the topics list' do
topic = Topic.create! valid_attributes
delete :destroy, { id: topic.to_param }, valid_session
expect(response).to redirect_to(topics_url)
it 'return 204 NO CONTENT' do
delete :destroy, { id: topic.to_param, format: :json }
expect(response.status).to eq 204
end
end
end

14
spec/factories/mappings.rb Normal file
View file

@ -0,0 +1,14 @@
FactoryGirl.define do
factory :mapping do
xloc 0
yloc 0
map
user
association :mappable, factory: :topic
factory :mapping_random_location do
xloc { rand(-100...100) }
yloc { rand(-100...100) }
end
end
end

3
spec/factories/metacodes.rb
View file

@ -1,4 +1,7 @@
FactoryGirl.define do
factory :metacode do
sequence(:name) { |n| "Cool Metacode ##{n}" }
icon 'https://images.com/image.png'
color '#cccccc'
end
end

3
spec/factories/synapses.rb
View file

@ -1,9 +1,10 @@
FactoryGirl.define do
factory :synapse do
sequence(:desc) { |n| "Cool synapse ##{n}" }
category :to
category :'from-to'
permission :commons
association :topic1, factory: :topic
association :topic2, factory: :topic
user
end
end

8
spec/models/mapping_spec.rb
View file

@ -1,5 +1,11 @@
require 'rails_helper'
RSpec.describe Mapping, type: :model do
pending "add some examples to (or delete) #{__FILE__}"
it { is_expected.to belong_to :user }
it { is_expected.to belong_to :map }
it { is_expected.to belong_to :mappable }
it { is_expected.to validate_presence_of :xloc }
it { is_expected.to validate_presence_of :yloc }
it { is_expected.to validate_presence_of :map }
it { is_expected.to validate_presence_of :mappable }
end

4
spec/models/metacode_spec.rb
View file

@ -1,6 +1,6 @@
require 'rails_helper'
RSpec.describe Metacode, type: :model do
pending "add some examples to (or delete) #{__FILE__}"
it { is_expected.to have_many(:topics) }
it { is_expected.to have_many :topics }
it { is_expected.to have_many :metacode_sets }
end

1
spec/models/synapse_spec.rb
View file

@ -8,6 +8,7 @@ RSpec.describe Synapse, type: :model do
it { is_expected.to have_many :mappings }
it { is_expected.to validate_presence_of :permission }
it { is_expected.to validate_inclusion_of(:permission).in_array Perm::ISSIONS.map(&:to_s) }
it { is_expected.to validate_inclusion_of(:category).in_array ['from-to', 'both'] }
it { is_expected.to validate_length_of(:desc).is_at_least(0) } # TODO don't allow nil
context 'permissions' do

0
spec/schemas/map.json Normal file
View file

42
spec/schemas/map_contains.json Normal file
View file

@ -0,0 +1,42 @@
{
"name": "Map Contents",
"type": "object",
"properties": {
"map": {
"type": "object"
},
"topics": {
"type": "array",
"items": {
"type": "object"
}
},
"synapses": {
"type": "array",
"items": {
"type": "object"
}
},
"mappings": {
"type": "array",
"items": {
"type": "object"
}
},
"mappers": {
"type": "array",
"items": {
"type": "object"
}
}
},
"required": [
"map",
"topics",
"synapses",
"mappings",
"mappers"
]
}

3
spec/spec_helper.rb
View file

@ -1,3 +1,6 @@
require 'simplecov'
require 'support/controller_helpers'
RSpec.configure do |config|
config.expect_with :rspec do |expectations|
expectations.include_chain_clauses_in_custom_matcher_descriptions = true

9
spec/support/controller_helpers.rb
View file

@ -1,4 +1,7 @@
# https://github.com/plataformatec/devise/wiki/How-To:-Stub-authentication-in-controller-specs
require 'devise'
module ControllerHelpers
# rubocop:disable Metrics/AbcSize
def sign_in(user = create(:user))
@ -7,6 +10,7 @@ module ControllerHelpers
receive(:authenticate!).and_throw(:warden, scope: :user)
)
else # simulate authenticated
allow_message_expectations_on_nil
allow(request.env['warden']).to(
receive(:authenticate!).and_return(user)
)
@ -15,3 +19,8 @@ module ControllerHelpers
end
# rubocop:enable Metrics/AbcSize
end
RSpec.configure do |config|
config.include Devise::TestHelpers, :type => :controller
config.include ControllerHelpers, :type => :controller
end

7
spec/support/schema_matcher.rb Normal file
View file

@ -0,0 +1,7 @@
RSpec::Matchers.define :match_json_schema do |schema|
match do |json|
schema_directory = Rails.root.join('spec', 'schemas').to_s
schema_path = "#{schema_directory}/#{schema}.json"
JSON::Validator.validate!(schema_path, json)
end
end