introspective_grape 0.0.3

data/spec/models/user_location_spec.rb

@@ -0,0 +1,35 @@
+require 'rails_helper'
+
+RSpec.describe UserLocation, type: :model do
+  include LocationHelper
+  before :all do
+    create_test_airport
+  end
+
+  let(:user) { User.make! }
+
+  it "validates the detectable type" do 
+    ul = UserLocation.new(user: user, location: Location.last, detectable: Location.last, coords: rand_coords)
+    ul.valid?.should == false
+    ul.errors[:detectable_type].should == ["is not included in the list"]
+  end
+
+  it "logs a user's locations by beacon" do
+    beacon = LocationBeacon.last
+    p1 = user.user_locations.build(location: beacon.location, detectable: beacon, coords: rand_coords)
+    user.save.should == true
+    p2 = user.user_locations.build(location: beacon.location, detectable: beacon, coords: rand_coords)
+    user.save.should == true
+    user.user_locations.first.should == p2
+  end
+
+  it "logs a user's beacon location by gps" do
+    gps = LocationGps.last
+    p1 = user.user_locations.build(location: gps.location, detectable: gps, coords: rand_coords)
+    user.save.should == true
+    p2 = user.user_locations.build(location: gps.location, detectable: gps, coords: rand_coords)
+    user.save.should == true
+    user.user_locations.first.should == p2
+  end
+
+end

data/spec/models/user_project_job_spec.rb

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+RSpec.describe UserProjectJob, type: :model do
+
+  it "should delegate user name" do
+    UserProjectJob.make.name.should_not == nil
+  end
+
+  it "should delegate user email" do
+    UserProjectJob.make.email.should_not == nil
+  end
+
+  it "should delegate job title" do
+    UserProjectJob.make.title.should_not == nil
+  end
+
+  it "should scope job options by project" do 
+    ProjectJob.make!
+    ProjectJob.make!
+
+    p = Project.make!
+    j = Job.make!
+    p.jobs.push j
+    p.save
+    r = UserProjectJob.make!(project: p, job: j) 
+    UserProjectJob.options_for_job(p).should == p.jobs
+  end
+
+
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,125 @@
+require 'rails_helper'
+include ActionDispatch::TestProcess # -> fixture_file_upload
+
+RSpec.describe User, type: :model do
+  context 'User::Chatter' do 
+
+    def user(email)
+      User.find_by_email(email) || User.make!(email: email) 
+    end
+
+    it "uploads an avatar to AWS" do 
+      u = User.make
+      u.avatar = Image.new(file: fixture_file_upload( Rails.root+'../fixtures/images/exif.jpeg'))
+      u.save
+      u.avatar.file_processing?.should == false
+      
+      #u.avatar_url.should            =~ /medium\/exif.jpeg/
+      #u.avatar_url(:original).should =~ /original\/exif.jpeg/
+      #u.avatar_url(:thumb).should    =~ /thumb\/exif.jpeg/
+    end
+
+    context "chatting" do 
+      let(:sender) {  user('sender@springshot.com') }
+      let(:target) {  user('target1@springshot.com') }
+      let(:target2) { user('target2@springshot.com') }
+      let(:target3) { user('target3@springshot.com') }
+
+      let(:discussion) {
+        c = sender.chat([target,target2], 'Hey guys')
+        target2.reply( c, "What's up?")
+        c 
+      }
+
+
+      before :all do 
+        Chat.destroy_all
+      end
+
+      it "chatting a user returns a chat" do 
+        c = sender.chat(target, 'a private message')
+        c.kind_of?(Chat).should be_truthy
+      end
+
+      it "a user sees that she has new messages in a discussion" do 
+        discussion.save! # invoke create hooks on ChatMessage for ChatMessageUser
+        sender.new_messages?(discussion)[discussion.id].should == 1
+        target2.new_messages?(discussion)[discussion.id].should == 0
+        target.new_messages?(discussion)[discussion.id].should == 2
+      end
+
+      it "a user gets notifications for all new messages for all conversations" do
+        discussion.save!
+        chat2 = target.chat( [target2], "Come to E2")
+        target.reply( chat2, "Hurry")
+
+        target2.new_messages?[discussion.id].should == nil
+        target2.new_messages?[chat2.id].should == 2
+      end
+
+      it "a user sees her new messages" do 
+        discussion.save!
+
+        sender.read_messages.size.should == 1
+        sender.read_messages[0].message.should == "What's up?"
+
+        target.read_messages.size.should == 2
+        target.read_messages(discussion)[0].message.should == "Hey guys"
+        target.read_messages(discussion)[1].message.should == "What's up?"
+
+        target2.read_messages.size.should == 0
+        #target2.new_messages[0].message.should == "Hey guys"
+      end
+
+      it "users are notified when a new user is added to the chat" do
+        target2.add_chatters(discussion, target3)
+
+        sender.messages.last.message.should =~ /ADDED_USER/
+          target.messages.last.message.should =~ /ADDED_USER/
+          target2.messages.last.message.should =~ /ADDED_USER/
+          target3.messages.last.message.should =~ /ADDED_USER/
+      end
+
+      it "when a user drops out should not see subsequent messages" do
+        discussion.active_users.size.should == 3
+        target.leave_chat(discussion).should == true
+        # and if the user has left leaving again should register as a success
+        target.leave_chat(discussion).should == true
+        discussion.active_users.size.should == 2
+        sender.reply(discussion, 'I never liked target anyway.')
+
+        sender.messages.last.message.should == 'I never liked target anyway.'
+        target2.messages.last.message.should == 'I never liked target anyway.'
+
+        target.messages.last.message.should_not == 'I never liked target anyway.'
+        target.messages.last.message.should =~ /DEPARTS/
+      end
+
+      it "a user rejoins a chat and doesn't see messages while they were gone" do
+        target2.leave_chat(discussion)
+        sender.reply(discussion, "Where'd target2 go?")
+        sender.add_chatters( discussion, target2)
+
+        messages = target2.messages.order('created_at').map(&:message)
+        messages.include?("Where'd target2 go?").should be_falsey
+        messages.last.should =~ /ADDED_USER/
+      end
+
+      it "when a user reads a message it should mark the message as read" do
+        discussion.save!
+        target.chat_message_users.unread.size.should == 2
+        target.mark_messages_as_read(target.messages)
+        target.chat_message_users.unread.size.should == 0
+      end
+
+      it "should cascade deletes to chat_user, messages, and read logs" do
+        ChatUser.where(discussion.id).size.should == 3
+        ChatMessage.where(discussion.id).size.should == 2
+        discussion.destroy
+        ChatUser.where(discussion.id).size.should == 0
+        ChatMessage.where(discussion.id).size.should == 0
+      end
+    end
+  end
+
+end

data/spec/rails_helper.rb

@@ -0,0 +1,23 @@
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+require 'support/request_helpers'
+require 'support/pundit_helpers'
+Dir[Rails.root.join("../support/**/*.rb")].each { |f| require f }
+
+#load "#{Rails.root}/db/schema.rb"
+RSpec.configure do |config|
+  config.include Devise::TestHelpers, type: :controller
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+
+  # load helpers for the API tests
+  config.include RequestHelpers, type: :request
+  config.before(:each, type: :request) do
+    # run all requests as super user, test permissions under policies
+    with_authentication
+  end
+
+end
+

data/spec/requests/chat_api_spec.rb

@@ -0,0 +1,174 @@
+require "rails_helper"
+describe Dummy::ChatAPI, type: :request do
+
+  before :all do 
+    User.destroy_all
+    @without_authentication = true
+
+    @current_user = User.make!(email: "current_user@springshot.com")
+    @sender = User.make!(email: "sender@springshot.com")
+    @lurker = User.make!(email: "lurker@springshot.com")
+
+    @lurk = @sender.chat( @lurker, "Private conversation.")
+    @lurker.reply(@lurk, "the lurker has his own conversation that we don't want the current_user to see anywhere")
+
+    @pm = @sender.chat( @current_user, "Private conversation.")
+    @sender.reply(@pm, "I'm asking a question?")
+    @sender.reply(@pm, "you there?")
+
+    @chat = @sender.chat( [@lurker,@current_user], "We need to talk.")
+    @current_user.reply(@chat, "Is this about tough love?")
+  end
+
+  context "while current_user is the current user" do
+
+    before :each do
+      @chat.reload 
+      Grape::Endpoint.before_each do |endpoint|
+        allow(endpoint).to receive(:current_user) { @current_user }
+      end
+    end
+
+    it "should return a list of a user's chats" do
+      get "/api/v1/chats"
+      response.should be_success
+      json.size.should == 2
+      json.first['creator_id'].to_i.should == @sender.id
+      json.first['users'].size.should == Chat.find(json.first['id']).users.size
+    end
+
+    context :notifications do
+      it "should get new chat notifications" do
+        get "/api/v1/chats/notifications/"
+        response.should be_success
+        json.keys.size.should     == 1
+        json[@pm.id.to_s].should   == 3
+      end
+
+      it "should get new chat notifications for a particular chat" do
+        get "/api/v1/chats/notifications/", id: @pm.id
+        response.should be_success
+        json[@pm.id.to_s].should == 3
+      end
+
+      it "should return 0 for non-existent chats" do
+        get "/api/v1/chats/notifications/", id: 0
+        response.should be_success
+        json['0'].should == 0
+      end
+    end
+
+    context :messages do 
+
+      it "should get no new chat messages if user was last to reply" do
+        get "/api/v1/chats/messages", id: @chat.id, new: true
+        response.should be_success
+        json.size.should == 0
+      end
+
+      it "should get new chat messages if user recieves another reply" do
+        @sender.reply(@chat, "And now for something completely different.")
+        get "/api/v1/chats/messages", id: @chat.id, new: true
+        response.should be_success
+        json.size.should == 1
+      end
+
+      it "should mark all new messages from all chats as read if mark_as_read is true" do 
+        @sender.reply(@chat, 'A new response.')
+        @current_user.new_messages?.keys.size.should == 2
+        get "/api/v1/chats/messages", new: true, mark_as_read: true
+        response.should be_success
+        json.size.should == 4
+        @current_user.new_messages?.keys.size.should == 0
+      end
+    end
+
+
+    context :users do 
+      it "should list the users in a chat" do
+        get "/api/v1/chats/users", id: @chat.id
+        response.should be_success
+        json.size.should == 3
+        json.map{|u| u['email']}.sort.should == [ "current_user@springshot.com", "lurker@springshot.com", "sender@springshot.com" ]
+      end
+
+      it "should add a new user to a chat" do
+        new_user1 = User.make
+        new_user1.save!
+        post "/api/v1/chats/users", id: @chat.id, user_ids: new_user1.id
+        response.should be_success
+        json['status'].should == true
+        @chat.reload
+        @chat.active_users.include?(new_user1).should == true
+      end
+
+      it "should add new users to a chat" do
+        new_user1 = User.make
+        new_user2 = User.make
+        new_user1.save!
+        new_user2.save!
+        post "/api/v1/chats/users", id: @chat.id, user_ids: "#{new_user1.id},#{new_user2.id}"
+        response.should be_success
+        json['status'].should == true
+        @chat.reload
+        @chat.active_users.include?(new_user1).should == true
+        @chat.active_users.include?(new_user2).should == true
+      end
+
+      it "should be invalid to add an already active chat member to a chat" do
+        @chat.chat_users.size.should == 3
+        post "/api/v1/chats/users", id: @chat.id, user_ids: @chat.active_users.first.id
+        response.status.should == 400
+        json['error'].should == "#{@chat.active_users.first.name} is already present in this chat."
+        @chat.reload
+        @chat.chat_users.size.should == 3
+      end
+
+      it "should raise an error when an outsider tries to add themselves to a chat" do
+        post "/api/v1/chats/users", id: @lurk.id, user_ids: @current_user.id
+        response.status.should == 400 
+        json['error'].should == 'Only current chat participants can add users.'
+        @lurk.reload
+        @lurk.active_users.include?(@current_user).should == false
+      end
+
+    end
+
+    context :chat do
+      it "should start a new chat" do
+        post "/api/v1/chats", user_ids:@lurker.id, message: 'a new chat'
+        response.should be_success
+        json['creator_id'].should == @current_user.id
+        Chat.last.creator.should == @current_user
+        Chat.last.messages.map(&:message).first.should == 'a new chat'
+        @lurker.read_messages(Chat.last.id ).last.message.should == 'a new chat'
+      end
+
+      it "should reply to a chat" do
+        put "/api/v1/chats/#{@chat.id}", message: 'A reply.'
+        response.should be_success
+        ChatMessage.last.author.should == @current_user
+        @sender.read_messages(Chat.last.id ).last.message.should == 'A reply.'
+        @lurker.read_messages(Chat.last.id ).last.message.should == 'A reply.'
+      end
+
+      it "should leave a chat" do
+        delete "/api/v1/chats/#{@chat.id}"
+        response.should be_success
+        json['status'].should == true
+        @chat.reload
+        @chat.active_users.include?(@current_user).should == false
+      end
+
+      it "should only allow chat participants to reply" do 
+        @current_user.leave_chat(@chat)
+        @current_user.reload
+        put "/api/v1/chats/#{@chat.id}", message: "I'm an interloper"
+        response.status.should == 400
+        json['error'].should == 'Messages: is invalid'
+        @chat.messages.last.should_not == "I'm an interloper"
+      end
+    end
+  end
+
+end

data/spec/requests/company_api_spec.rb

@@ -0,0 +1,61 @@
+require 'rails_helper'
+
+describe Dummy::CompanyAPI, type: :request do
+  before :all do
+    Company.find_by_name("Sprockets") || Company.make!(name:"Sprockets")
+  end
+
+  let(:company) { Company.find_by_name("Sprockets") }
+
+  it "should return a list of companies" do
+    get '/api/v1/companies'
+    response.should be_success
+    json.length.should > 0
+    json.map{|c| c['id'].to_i}.include?(company.id).should == true
+  end
+
+  it "should return the specified company" do
+    get "/api/v1/companies/#{company.id}"
+    response.should be_success
+    json['name'].should == company.name
+  end
+
+  it "should return an error if the company doesn't exist" do
+    get "/api/v1/companies/#{Company.last.id+1}"
+    response.code.should == "404"
+  end
+
+
+  it "should create a company" do
+    post "/api/v1/companies", { name: 'Test 123', short_name: 'T123' } 
+    response.should be_success
+    json['name'].should       == "Test 123"
+    json['short_name'].should == "T123"
+  end
+  
+  it "should validate a new company" do
+    post "/api/v1/companies", { name: 'a'*257, short_name: 'a'*11 }
+    response.code.should == "400"
+    json['error'].should == "Name: is too long (maximum is 256 characters), Short Name: is too long (maximum is 10 characters)"
+  end
+
+
+  it "should update the company" do
+    new_name = 'New Test 1234'
+    put "/api/v1/companies/#{company.id}", { name: new_name } 
+    response.should be_success
+    company.reload
+    company.name.should == new_name
+    json['name'].should == new_name
+  end
+
+  it "should validate the company on update" do
+    old_name = company.name
+    put "/api/v1/companies/#{company.id}", { name: 'a'*257, short_name: 'a'*11 }
+    response.code.should == "400"
+    company.reload
+    company.name.should == old_name
+    json['error'].should == "Name: is too long (maximum is 256 characters), Short Name: is too long (maximum is 10 characters)"
+  end
+
+end

data/spec/requests/location_api_spec.rb

@@ -0,0 +1,96 @@
+require 'rails_helper'
+
+describe Dummy::LocationAPI, type: :request do
+  include LocationHelper
+
+  let(:location) { Location.find_by_name("TEST") }
+
+  before :all do
+    create_test_airport
+  end
+
+  it "should return a list of top level locations and their children" do
+    get '/api/v1/locations'
+    response.should be_success
+    json.length.should > 0
+    json.map{|l| l['id'].to_i }.include?(location.id).should == true
+
+    json.first['child_locations'].size.should > 0
+    json.first['child_locations'].map{|l| l['id'].to_i}.sort.should == location.child_locations.map(&:id).sort
+  end
+
+  it "should return the specified location" do
+    get "/api/v1/locations/#{location.id}"
+    response.should be_success
+    json['name'].should == location.name
+  end
+
+  it "should return an error if the location doesn't exist" do
+    get "/api/v1/locations/#{Location.last.id+1}"
+    response.code.should == "404"
+  end
+
+  it "should create a location" do
+    post "/api/v1/locations", { name: 'Test 123', kind: "terminal" } 
+    response.should be_success
+    json['name'].should == "Test 123"
+  end
+  
+  it "should create a location with a beacon" do
+    b = LocationBeacon.make(company: Company.last)
+    post "/api/v1/locations", { name: 'Test 123', kind: "gate", beacons_attributes: [ b.attributes ] } 
+    response.should be_success
+    json['name'].should == "Test 123"
+    l   = Location.find(json['id'])
+    created = l.beacons.first
+    created.uuid.should   == b.uuid.gsub(/-/,'').upcase
+    created.minor.should  == b.minor
+    created.major.should  == b.major
+  end
+ 
+  it "should create a location with gps coordinates" do
+    gps = LocationGps.make
+    post "/api/v1/locations", { name: 'Test 123', kind: "airport", gps_attributes: gps.attributes } 
+    response.should be_success
+    json['name'].should == "Test 123"
+    l   = Location.find(json['id'])
+    created = l.gps
+    # Ruby and Postgres do not share the same floating point precision
+    created.lat.round(10).should == gps.lat.round(10)
+    created.lng.round(10).should == gps.lng.round(10)
+    created.alt.should           == gps.alt
+  end
+  
+  it "should validate a new location" do
+    post "/api/v1/locations", { name: 'test' }
+    response.code.should == "400"
+    json['error'].should == "Kind: is not included in the list"
+  end
+
+  it "should update the location" do
+    new_name = 'New Test 1234'
+    put "/api/v1/locations/#{location.id}", { name: new_name } 
+    response.should be_success
+    location.reload
+    location.name.should == new_name
+    json['name'].should == new_name
+  end
+
+  it "should validate the location on update" do
+    old_kind = location.kind
+    put "/api/v1/locations/#{location.id}", { kind: 'bring the noise' }
+    response.code.should == "400"
+    location.reload
+    location.kind.should == old_kind
+    json['error'].should == 'Kind: is not included in the list'
+  end
+
+  it "should destroy the location and all of its child and grandchild locations" do
+    child_locations = location.child_locations.map {|l| [l.id, l.child_locations.map(&:id)] }.flatten
+    delete "/api/v1/locations/#{location.id}"
+    response.should be_success
+    Location.find_by_id(location.id).should == nil
+    Location.where(id: child_locations).size.should == 0
+  end
+
+end