clever-ruby 0.14.0 → 1.0.0

data/test/integration/api_operations/list_test.rb

@@ -1,117 +0,0 @@
-require 'test_helper'
-
-def resource_name(resource)
-  resource.shortname
-end
-
-# The DistrictAdmin resource does not support the count or limit parameters
-def limitable_countable_resources
-  [Clever::District, Clever::School, Clever::Teacher,
-   Clever::Student, Clever::Section, Clever::Event,
-   Clever::SchoolAdmin]
-end
-
-def resources
-  limitable_countable_resources + [Clever::DistrictAdmin]
-end
-
-module Minitest
-  # Extend default Minitest assertions
-  module Assertions
-    def assert_resource_type(resource, elem)
-      assert_instance_of resource, elem, "All elems of #{resource.url} should be of "\
-        "type #{resource.name}, instead got #{elem.class.name}. elem: #{elem.inspect}"
-    end
-  end
-end
-
-# Test api_operations/List
-describe Clever::APIOperations::List, :vcr do
-  before do
-    Clever.configure do |config|
-      config.token = 'DEMO_TOKEN'
-    end
-  end
-
-  [[Clever::District, 1], [Clever::School, 3], [Clever::Teacher, 89],
-   [Clever::Student, 1004], [Clever::Section, 379], [Clever::Event, 7],
-   [Clever::SchoolAdmin, 1]].each do |test_data|
-    resource, expected = test_data
-    name = resource_name resource
-
-    it "counts #{name} properly" do
-      count = resource.count
-      assert count.is_a?(Integer), "count should return an Integer. count: #{count}"
-      assert_equal expected, count, "Expected #{expected} #{name}s to exist, "\
-        "but only #{count} were found. Perhaps the test data has changed?"
-    end
-  end
-
-  resources.each do |resource|
-    name = resource_name resource
-
-    it "rejects invalid id for #{resource}.find one" do
-      id = 'invalid_id'
-      assert_raises(ArgumentError) { resource.find id }
-    end
-
-    it "finds a single #{name}" do
-      id = resource.find.take(20).last.id
-      elem = resource.find id
-      assert_resource_type resource, elem
-      assert_equal id, elem.id
-    end
-  end
-
-  limitable_countable_resources.each do |resource|
-    name = resource_name resource
-
-    it 'rejects invalid ids for Clever::District.find multiple' do
-      # one valid, one invalid
-      ids = %w(123412341234123412341234 invalid_id)
-      assert_raises(ArgumentError) { Clever::District.find ids }
-    end
-
-    it "finds #{name}s with multiple ids" do
-      to_query = []
-      count = 0
-      limit = 20
-      resource.find(nil, limit: limit).take(limit).each do |elem|
-        to_query << elem.id if count.even?
-        count += 1
-      end
-
-      return if to_query.count == 0
-      found = resource.find(to_query).map(&:id)
-      assert_equal to_query.sort, found.sort, 'Elements found by querying by array of ids '\
-        "should match the query itself. Expected: #{to_query.inspect}, found: #{found.inspect}"
-    end
-
-    it "finds #{name}s by page" do
-      result = resource.find
-      assert_instance_of Clever::APIOperations::ResultsList, result, 'Result should be '\
-        "a Clever::APIOperations::ResultsList, received #{result.inspect}"
-      count = 0
-      result.each do |elem|
-        count += 1
-        assert_resource_type resource, elem
-      end
-
-      expected = resource.count
-      count.must_equal expected, "Expected #{expected} #{name}s to be "\
-        "retrieved but only #{count} were found. Perhaps the test data has changed?"
-    end
-
-    it "retrieves all #{name}" do
-      elems = resource.all
-      elems.each do |elem|
-        assert_instance_of resource, elem, "All elems of #{resource.url} should be of "\
-          "type #{resource.name}, instead got #{elem.class.name}. elem: #{elem.inspect}"
-      end
-
-      expected = resource.count
-      elems.length.must_equal expected, "Expected #{expected} #{name}s to be "\
-        "retrieved but only #{elems.length} were found. Perhaps the test data has changed?"
-    end
-  end
-end

data/test/integration/district_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Minitest
-  # Add assertions to Minitest
-  module Assertions
-    def assert_valid_object_pages(object_name, limit, page_count)
-      district = Clever::District.all.first
-      object_count_from_list = district.send("#{object_name}s", limit: 100_000).size
-
-      object_count_from_paging = 0
-      pages = 0
-      district.send("#{object_name}_pages", limit: limit).each do |object_page|
-        pages += 1
-        objects = object_page.all
-        object_count_from_paging += objects.size
-      end
-
-      object_count_from_paging.must_equal object_count_from_list
-      pages.must_equal page_count
-    end
-  end
-end
-
-describe Clever::District, :vcr do
-  before do
-    Clever.configure do |config|
-      config.token = 'DEMO_TOKEN'
-    end
-  end
-
-  # TODO: this is outdated and should be removed!
-  describe 'pages methods' do
-    it "pages a district's schools" do
-      assert_valid_object_pages 'school', 2, 2
-    end
-
-    it "pages a district's teachers" do
-      assert_valid_object_pages 'teacher', 10, 9
-    end
-
-    it "pages a district's sections" do
-      assert_valid_object_pages 'section', 10, 38
-    end
-
-    it "pages a district's students" do
-      assert_valid_object_pages 'student', 50, 21
-    end
-
-    it "pages a district's events" do
-      assert_valid_object_pages 'event', 1, 8
-    end
-  end
-end

data/test/integration/district_with_non_global_token_test.rb

@@ -1,88 +0,0 @@
-require 'test_helper'
-
-module Minitest
-  # Add assertions to Minitest
-  module Assertions
-    def assert_valid_object_list(plural_object_name, object_count, instance_name)
-      district = Clever::District.retrieve('4fd43cc56d11340000000005', 'DEMO_TOKEN')
-      district.send(plural_object_name).size.must_equal object_count
-      district.send(plural_object_name).first.must_be_instance_of instance_name
-    end
-
-    def assert_valid_object_pages(object_name, limit, page_count)
-      district = Clever::District.retrieve('4fd43cc56d11340000000005', 'DEMO_TOKEN')
-      object_count_from_list = district.send("#{object_name}s", limit: 100_000).size
-
-      object_count_from_paging = 0
-      pages = 0
-      district.send("#{object_name}_pages", limit: limit).each do |object_page|
-        pages += 1
-        objects = object_page.all
-        object_count_from_paging += objects.size
-      end
-
-      object_count_from_paging.must_equal object_count_from_list
-      pages.must_equal page_count
-    end
-  end
-end
-
-describe 'Clever::District without global token', :vcr do
-  before do
-    Clever.configure do |config|
-      config.token = nil
-    end
-  end
-
-  it "retrieves a district's schools" do
-    assert_valid_object_list 'schools', 3, Clever::School
-  end
-
-  it "retrieves a district's teachers" do
-    assert_valid_object_list 'teachers', 89, Clever::Teacher
-  end
-
-  it "retrieves a district's sections" do
-    VCR.use_cassette('Clever_District_without_global_token/retrieves_a_district_s_sections',
-                     allow_playback_repeats: true) do
-      assert_valid_object_list 'sections', 379, Clever::Section
-    end
-  end
-
-  it "retrieves a district's students" do
-    VCR.use_cassette('Clever_District_without_global_token/retrieves_a_district_s_students',
-                     allow_playback_repeats: true) do
-      assert_valid_object_list 'students', 1004, Clever::Student
-    end
-  end
-
-  it "retrieves a district's school admins" do
-    VCR.use_cassette('Clever_District_without_global_token/retrieves_a_district_s_school_admins',
-                     allow_playback_repeats: true) do
-      assert_valid_object_list 'school_admins', 1, Clever::SchoolAdmin
-    end
-  end
-
-  # TODO: this is outdated and should be removed!
-  describe 'pages methods' do
-    it "pages a district's schools" do
-      assert_valid_object_pages 'school', 2, 2
-    end
-
-    it "pages a district's teachers" do
-      assert_valid_object_pages 'teacher', 10, 9
-    end
-
-    it "pages a district's sections" do
-      assert_valid_object_pages 'section', 10, 38
-    end
-
-    it "pages a district's students" do
-      assert_valid_object_pages 'student', 50, 21
-    end
-
-    it "pages a district's events" do
-      assert_valid_object_pages 'event', 2, 1
-    end
-  end
-end

data/test/integration/error_handling_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-
-# Test error handling
-describe 'Error handling', :vcr do
-  before do
-    Clever.configure do |config|
-      config.token = 'DEMO_TOKEN'
-    end
-  end
-
-  it 'raises an InvalidRequestError when given a bad created_since' do
-    @district = Clever::District.find.first
-    lambda do
-      @district.events(created_since: '2013-02-15T 2:30:42 0000').first
-    end.must_raise Clever::InvalidRequestError
-  end
-end

data/test/integration/last_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-describe 'last method', :vcr do
-  before do
-    Clever.configure do |config|
-      config.token = 'DEMO_TOKEN'
-    end
-  end
-
-  # The DistrictAdmin resource does not support the last method (limit parameter)
-  resources = [Clever::District, Clever::School, Clever::Student,
-               Clever::Event, Clever::Section, Clever::Teacher,
-               Clever::SchoolAdmin]
-
-  describe 'page' do
-    it 'has working first and last methods' do
-      resources.each do |resource|
-        page = Clever::APIOperations::Page.new resource.url
-        list = page.all
-
-        page.first.must_equal list.first
-        page.last.must_equal list.last
-        page.first(10).must_equal list.first(10)
-        page.last(10).must_equal list.last(10)
-      end
-    end
-  end
-
-  describe 'nested resource' do
-    it 'has working first and last methods' do
-      resources.each do |resource|
-        resource.linked_resources do |l|
-          nested = resource.first.send l
-          nested_resource = Clever::APIResource.named l
-          if Clever::APIResource.singular? l
-            nested.first.must_be_instance_of nested_resource
-          else
-            nested.first.must_be_instance_of nested_resource
-            nested.first(10).each do |e|
-              e.must_be_intsance_of nested_resource
-            end
-
-            last = nested.last
-            last.must_be_instance_of nested_resource
-            count = 0
-            nested.last(10).each do |e|
-              e.must_be_intsance_of nested_resource
-              e.must_equal last if count == 19
-              count += 1
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/test/integration/nested_resource_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-describe Clever::NestedResource, :vcr do
-  before do
-    Clever.configure do |config|
-      config.token = 'DEMO_TOKEN'
-    end
-  end
-
-  [Clever::District, Clever::School, Clever::Student,
-   Clever::Event, Clever::Section, Clever::Teacher,
-   Clever::SchoolAdmin, Clever::DistrictAdmin].each do |resource|
-    next if resource.linked_resources.nil?
-    resource.linked_resources.each do |link|
-      it "retrieves a #{resource.shortname}'s #{link}" do
-        result = resource.find.first.send link
-        if Clever::APIResource.singular?(link.to_s)
-          result.must_be_instance_of Clever::APIResource.named(link.to_s)
-        else
-          result.must_be_instance_of Clever::NestedResource
-          result.size.must_equal result.count # check count request measures actual data size
-        end
-      end
-    end
-  end
-
-  it 'must include auth_token in linked_resources' do
-    school = Clever::District.find.first.send(:schools).first
-    school.auth_token.must_equal 'DEMO_TOKEN'
-  end
-end

data/test/test_helper.rb

@@ -1,18 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'minitest/autorun'
-require 'minispec-metadata'
-require 'vcr'
-require 'minitest-vcr'
-require 'clever-ruby'
-
-questionmark_agnostic_matcher = lambda do |request1, request2|
-  request1.uri.sub(/\?\z/, '') == request2.uri.sub(/\?\z/, '')
-end
-
-VCR.configure do |c|
-  c.default_cassette_options = { match_requests_on: [:method, questionmark_agnostic_matcher] }
-  c.cassette_library_dir = 'test/data/vcr_cassettes'
-  c.hook_into :webmock
-end
-MinitestVcr::Spec.configure!

data/test/unit/api_resource_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-describe Clever::APIResource do
-  let :resources do
-    { district: { plural: 'districts', klass: Clever::District },
-      school: { plural: 'schools', klass: Clever::School },
-      section: { plural: 'sections', klass: Clever::Section },
-      event: { plural: 'events', klass: Clever::Event },
-      teacher: { plural: 'teachers', klass: Clever::Teacher },
-      student: { plural: 'students', klass: Clever::Student },
-      school_admin: { plural: 'school_admins', klass: Clever::SchoolAdmin },
-      district_admin: { plural: 'district_admins', klass: Clever::DistrictAdmin } }
-  end
-
-  describe :singular do
-    it 'identifies singular and plural resource names' do
-      resources.each do |singular, klass_info|
-        Clever::APIResource.singular?(singular).must_equal true
-        Clever::APIResource.singular?(klass_info[:plural]).must_equal false
-      end
-    end
-
-    it 'fails on non-resource names' do
-      -> { Clever::APIResource.singular?('thing') }.must_raise RuntimeError
-    end
-  end
-
-  describe :named do
-    it 'returns nil on nonexistent resources' do
-      Clever::APIResource.named('fake_resource').must_equal nil
-    end
-
-    it 'returns valid responses for both symbol and string inputs' do
-      resources.each do |res_name, klass_info|
-        Clever::APIResource.named(res_name.to_s).must_equal klass_info[:klass]
-        Clever::APIResource.named(res_name.to_sym).must_equal klass_info[:klass]
-      end
-    end
-
-    it 'returns valid responses for both singular and plural words' do
-      resources.each do |res_name, klass_info|
-        Clever::APIResource.named(res_name.to_s).must_equal klass_info[:klass]
-        Clever::APIResource.named(
-          klass_info[:plural]).must_equal klass_info[:klass]
-      end
-    end
-  end
-end

data/test/unit/clever_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-require 'json'
-
-# basic clever-ruby tests
-# TODO: organize better
-describe Clever do
-  before do
-    Clever.configure do |config|
-      config.token = 'DEMO_TOKEN'
-    end
-  end
-
-  it 'returns correct urls for Resources' do
-    assert_equal 'v1.1/districts', Clever::District.url
-    assert_equal 'v1.1/schools', Clever::School.url
-    assert_equal 'v1.1/students', Clever::Student.url
-    assert_equal 'v1.1/sections', Clever::Section.url
-    assert_equal 'v1.1/teachers', Clever::Teacher.url
-    assert_equal 'v1.1/events', Clever::Event.url
-    assert_equal 'v1.1/school_admins', Clever::SchoolAdmin.url
-    assert_equal 'v1.1/district_admins', Clever::DistrictAdmin.url
-  end
-
-  it 'uri-encodes params' do
-    query_string = Clever.convert_to_query_string created_at: '2013-02-15T 2:30:42Z'
-    query_string.must_equal 'created_at=2013-02-15T%202:30:42Z'
-  end
-
-  describe '.create_request_opts' do
-    before do
-      method, url = 'get', 'quotes'
-      params = { education: 'powerful weapon' }
-      headers = { author: 'Nelson Mandela' }
-      @options = Clever.create_request_opts method, url, params, headers
-    end
-    it 'sets method and url' do
-      assert_equal 'get', @options[:method], 'Method not set properly'
-      assert_equal(
-        'https://api.clever.com/quotes?education=powerful%20weapon',
-        @options[:url],
-        'URL not formed properly with params')
-    end
-    it 'adds tracking headers' do
-      headers = @options[:headers]
-      assert headers.key?(:Authorization), 'Did not set authorization header'
-      assert_match(/Bearer/, headers[:Authorization])
-      assert headers.key?(:user_agent), 'Did not set User Agent header'
-      assert_match %r{Clever/RubyBindings/}, headers[:user_agent]
-      assert(
-        headers.key?(:x_clever_client_user_agent),
-        'Did not set Clever Client User Agent header')
-      assert headers.key?(:author), 'Did not keep original header'
-
-      custom_ua = JSON.parse(headers[:x_clever_client_user_agent], symbolize_names: true)
-      assert custom_ua.key?(:lang), 'Did not set lang in custom user agent header'
-      assert_equal custom_ua[:lang], 'ruby', 'Lang is not set to ruby'
-      assert custom_ua.key?(:lang_version), 'Did not set lang_version in custom user agent header'
-      assert custom_ua.key?(:platform), 'Did not set platform in custom user agent header'
-      assert custom_ua.key?(:uname), 'Did not set uname in custom user agent header'
-      assert custom_ua.key?(:publisher), 'Did not set publisher in custom user agent header'
-      assert_equal custom_ua[:publisher], 'clever', 'Did not set publisher to clever'
-      assert custom_ua.key?(:bindings_version), 'Did not set bindings_version'
-    end
-  end
-end