Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

390 lines (340 sloc) 10.662 kB
require 'helper'
require 'parse_resource'
ParseResource::Base.load!(ENV["PARSE_RESOURCE_APPLICATION_ID"], ENV["PARSE_RESOURCE_MASTER_KEY"])
class Post < ParseResource::Base
fields :title, :body, :author
validates_presence_of :title
end
class Author < ParseResource::Base
field :name
end
class Spoon < ParseResource::Base
fields :width, :length
end
class Fork < ParseResource::Base
fields :points
end
class Knife < ParseResource::Base
fields :is_shiny
end
class Straw < ParseResource::Base
fields :title, :body
end
class Event < ParseResource::Base
field :name
end
class TestParseResource < Test::Unit::TestCase
#def setup
# Post.destroy_all
# Author.destroy_all
# Spoon.destroy_all
# Fork.destroy_all
# Straw.destroy_all
#end
#def teardown
# Post.destroy_all
# Author.destroy_all
# Spoon.destroy_all
# Fork.destroy_all
# Straw.destroy_all
#end
def test_initialize_without_args
assert Post.new.is_a?(Post)
end
def test_count
VCR.use_cassette('test_count', :record => :new_episodes) do
Author.destroy_all
p1 = Author.create(:name => "bar")
p2 = Author.create(:name => "jab")
assert_equal 2, Author.count
assert_equal 1, Author.where(:name => "jab").count
p1.destroy
p2.destroy
assert_equal 0, Author.count
end
end
def test_initialize_with_args
@spoon = Spoon.new(:length => "title1", :width => "ipso")
assert @spoon.is_a?(Spoon)
assert_equal "title1", @spoon.length
assert_equal "ipso", @spoon.width
end
def test_create
VCR.use_cassette('test_create', :record => :new_episodes) do
Spoon.destroy_all
s = Spoon.create(:length => "1234567890created!")
assert s.is_a?(Spoon)
assert s.id
assert s.created_at
end
end
def test_find
VCR.use_cassette('test_find', :record => :new_episodes) do
Spoon.destroy_all
p1 = Spoon.create(:length => "Welcome")
p2 = Spoon.find(p1.id)
assert_equal p2.id, p2.id
end
end
def test_find_should_throw_an_exception_if_object_is_nil
VCR.use_cassette('test_find_should_throw_an_exception_if_object_is_nil', :record => :new_episodes) do
assert_raise RecordNotFound do
Post.find("")
end
end
end
def test_find_should_throw_an_exception_if_object_does_not_exist
VCR.use_cassette('test_find_should_throw_an_exception_if_object_is_nil', :record => :new_episodes) do
assert_raise RecordNotFound do
Post.find("id does not exist")
end
end
end
def test_first
VCR.use_cassette('test_first', :record => :new_episodes) do
Fork.destroy_all
f = Fork.create(:points => "firsttt")
p = Fork.first
assert p.is_a?(Fork)
assert f.id, p.id
assert f.points, p.points
end
end
def test_find_by
VCR.use_cassette('test_find_by', :record => :new_episodes) do
p1 = Post.create(:title => "Welcome111")
where = Post.where(:title => "Welcome111").first
find = Post.find_by_title("Welcome111")
assert_equal where.id, find.id
end
end
def test_find_all_by
VCR.use_cassette('test_find_all_by', :record => :new_episodes) do
p1 = Post.create(:title => "Welcome111")
where = Post.where(:title => "Welcome111").all
find = Post.find_all_by_title("Welcome111")
assert_equal where.first.id, find.first.id
assert_equal find.class, Array
end
end
def test_where
VCR.use_cassette('test_where', :record => :new_episodes) do
p1 = Post.create(:title => "Welcome111")
p2 = Post.where(:title => "Welcome111").first
assert_equal p2.title, p1.title
end
end
def test_destroy_all
VCR.use_cassette('test_destroy_all', :record => :new_episodes) do
p = Knife.create(:is_shiny => "arbitrary")
Knife.destroy_all
assert_equal Knife.count, 0
end
end
def test_chained_wheres
VCR.use_cassette('test_chained_wheres', :record => :new_episodes) do
Straw.destroy_all
p1 = Straw.create(:title => "chained_wheres", :body => "testing")
p2 = Straw.create(:title => "chained_wheres", :body => "testing_2")
query = Straw.where(:title => "chained_wheres").where(:body => "testing")
p3 = query.first
assert_equal p3.id, p1.id
end
end
def test_limit
VCR.use_cassette('test_limit', :record => :new_episodes) do
Post.destroy_all
15.times do |i|
Post.create(:title => "foo_"+i.to_s)
end
posts = Post.limit(5).all
assert_equal posts.length, 5
end
end
def test_order_descending
VCR.use_cassette('test_order_descending', :record => :new_episodes) do
Event.destroy_all
e1 = Event.create(:name => "1st")
e2 = Event.create(:name => "2nd")
events = Event.order("name desc").all
assert_equal "2nd", events.first.name
end
end
def test_order_ascending
VCR.use_cassette('test_order_ascending', :record => :new_episodes) do
Author.destroy_all
e1 = Author.create(:name => "1st")
e2 = Author.create(:name => "2nd")
events = Author.order("name asc").all
assert_equal "1st", events.first.name
end
end
def test_skip
VCR.use_cassette('test_skip', :record => :new_episodes) do
Post.destroy_all
posts = []
15.times do |i|
posts << Post.new(:title => "skip", :author => "#{i}-author")
end
Post.save_all(posts)
assert_equal 15, Post.count # Sanity check
post = Post.where(:title => "skip").skip(14).first
assert_equal "14-author", post.author # Starts at 0, so this is the next one
end
end
def test_all
VCR.use_cassette('test_all', :record => :new_episodes) do
Post.destroy_all
Post.create(:title => "11222")
Post.create(:title => "112ssd22")
posts = Post.all
assert posts.is_a?(Array)
assert posts[0].is_a?(Post)
end
end
def test_attribute_getters
VCR.use_cassette('test_attribute_getters', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "title1")
assert_equal @post.attributes['title'], "title1"
assert_equal @post.attributes['title'], @post.title
end
end
def test_attribute_setters
VCR.use_cassette('test_attribute_setters', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "1")
@post.body = "newerbody"
assert_equal @post.body, "newerbody"
end
end
def test_save
VCR.use_cassette('test_save', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "testing save")
@post.save
assert @post.attributes['objectId']
assert @post.attributes['updatedAt']
assert @post.attributes['createdAt']
end
end
def test_each
VCR.use_cassette('test_each', :record => :new_episodes) do
Post.destroy_all
ps = []
4.times do |i|
ps << Post.create(:title => "each")
end
Post.save_all(ps)
posts = Post.where(:title => "each")
posts.each do |p|
assert_equal p.title, "each"
end
end
end
def test_map
VCR.use_cassette('test_map', :record => :new_episodes) do
Post.destroy_all
4.times do |i|
Post.create(:title => "map")
end
posts = Post.where(:title => "map")
assert_equal posts.map {|p| p}.class, Array
end
end
def test_id
VCR.use_cassette('test_id', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "testing id")
assert @post.respond_to?(:id)
assert @post.id
assert @post.attributes['objectId'] = @post.id
end
end
def test_created_at
VCR.use_cassette('test_created_at', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "testing created_at")
assert @post.respond_to?(:created_at)
assert @post.created_at
assert @post.attributes['createdAt']
end
end
def test_updated_at
VCR.use_cassette('test_updated_at', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "testing updated_at")
@post.title = "something else"
@post.save
assert @post.updated_at
end
end
def test_update
VCR.use_cassette('test_update', :record => :new_episodes) do
Post.destroy_all
@post = Post.create(:title => "stale title")
updated_once = @post.updated_at
@post.update(:title => "updated title")
assert_equal @post.title, "updated title"
@post.title = "updated from setter"
assert_equal @post.title, "updated from setter"
assert_not_equal @post.updated_at, updated_once
end
end
def test_destroy
VCR.use_cassette('test_destroy', :record => :new_episodes) do
Post.destroy_all
p = Post.create(:title => "hello1234567890abc!")
id = p.id
p.destroy
assert_equal p.title, nil
assert_equal 0, Post.where(:title => "hello1234567890abc!", :objectId => id).length
end
end
def test_validation
p = Post.new
assert !p.valid?
p.title = "foo"
assert p.valid?
end
def test_to_pointer
VCR.use_cassette('test_to_pointer', :record => :new_episodes) do
p = Post.create
array = {"__type" => "Pointer", "className"=>"Post", "objectId" => p.id}
assert_equal array, p.to_pointer
end
end
def test_to_date_object
VCR.use_cassette('test_to_date_object', :record => :new_episodes) do
date = DateTime.strptime("Thu, 11 Oct 2012 10:20:40 -0700", '%a, %d %b %Y %H:%M:%S %z')
array = {"__type"=>"Date", "iso"=>"2012-10-11T17:20:40Z"}
date_pointer = Post.to_date_object(date)
assert_equal array["__type"], date_pointer["__type"]
assert_equal array["iso"], date_pointer["iso"]
end
end
def test_save_all_and_destroy_all
VCR.use_cassette('test_save_all_and_destroy_all', :record => :new_episodes) do
Post.destroy_all
objs = []
25.times { |t| objs << Post.new(:title => "post #{t}") }
Post.save_all(objs)
assert_equal 25, Post.count
Post.destroy_all(objs)
assert_equal 0, Post.count
end
end
def test_chunk
VCR.use_cassette('test_chunk', :record => :new_episodes) do
Post.destroy_all
objs = []
25.times { |t| objs << Post.new(:title => "post") }
Post.save_all(objs)
assert_equal 25, Post.count
posts = Post.where(:title => "post").limit(1000).chunk(5).all
assert_equal 25, posts.length
Post.destroy_all(objs)
assert_equal 0, Post.count
end
end
end
Jump to Line
Something went wrong with that request. Please try again.