require File.dirname(__FILE__) + '/../spec_helper'

describe Picture, 'associations' do
  it 'should belong to merchant' do
    Picture.new.should belong_to(:merchant)
  end
end

describe 'Maximum picture file size limit' do
  it 'should be given in megabytes' do
    Picture.max_upload_file_size_limit.should == (Picture::IMAGE_FILE_SIZE_RANGE.end / 1.megabyte)
  end
end

describe 'Valid image types list' do
  it 'should say gif, jpg or png' do
    Picture.valid_image_types_sentence.should == '.gif, .jpg or .png'
  end
end

describe Picture, 'protected attributes' do
  it 'should protect merchant id' do
    (@pic = Picture.new(:merchant_id => 0)).merchant_id.should_not == 0
  end
end

describe Picture, 'validations' do
  include PictureSpecHelper
  it 'should not prohibit upload of text files' do
    # No expensive I/O operation just to get file size!
    File.should_receive(:size).with(anything).and_return(0.25.megabytes)

    image = uploaded_file('text_file.txt')
    image.valid?
    image.errors.full_messages.should include('Image has unsupported format.')
  end

  it 'should prohibit upload of files greater than 2 megabytes' do
    # No expensive I/O operation just to get file size!
    File.should_receive(:size).with(anything).and_return(2.7.megabytes)
    image = uploaded_file('mail_in_leopard.png')
    image.valid?
    image.errors.full_messages.should include('Image is larger than the allowed size range.')
  end
end

describe Picture, 'new uploaded picture' do
  before :each do
    @new_pic = Picture.new
  end

  it 'should not be used as logo' do
    @new_pic.should_not be_logo
  end

  it 'should not be hidden' do
    @new_pic.should_not be_hidden
  end

  it 'should be unreviewed' do
    @new_pic.should_not be_reviewed
  end

  it 'should be appropriate' do
    @new_pic.should be_appropriate
  end

  it 'should not be marked innapropriate by user' do
    @new_pic.should_not be_user_inappropriate
  end
end


describe Picture, 'logo assignment' do
  fixtures :pictures

  before :each do
    @logo = pictures(:as_logo)
    @pic  = pictures(:one)
  end

  def use_picture_as_logo(picture)
    picture.use_as_logo!
  end

  it 'should have logo and non_logo(test prerequisite)' do
    @logo.should be_logo
    @pic.should_not be_logo
  end

  it 'should set logo attribute' do
    use_picture_as_logo(@pic)
    @pic.should be_logo
  end

  it 'should clear logo attribute(requires model reload)' do
    use_picture_as_logo(@pic)
    @logo.reload.should_not be_logo
  end
end

describe Picture, 'after hide' do
  fixtures :pictures

  it 'should be hidden' do
    (@pic = pictures(:not_hidden)).should_not be_hidden
    @pic.hide!
    @pic.should be_hidden
  end
end

describe Picture, 'after reveal' do
  fixtures :pictures
  it 'after unhide!' do
    (@pic = pictures(:hidden)).should be_hidden
    @pic.unhide!
    @pic.should_not be_hidden
  end
end

describe Picture, 'when marked inappropriate' do
  fixtures :pictures

  it 'should be reviewed' do
    (@pic = pictures(:unreviewed)).should_not be_reviewed
    @pic.inappropriate!
    @pic.should be_reviewed
  end

end

describe Picture, 'when marked appropriate' do
  fixtures :pictures
  it 'should be reviewed' do
    (@pic = pictures(:unreviewed)).should_not be_reviewed
    @pic.appropriate!
    @pic.should be_reviewed
  end
end


describe Picture, 'when marked as innapropriate by user' do
  fixtures :pictures
  it 'should not be reviewed' do
    (@pic = pictures(:unreviewed)).should_not be_reviewed
    @pic.user_inappropriate!
    @pic.should_not be_reviewed
  end
end

describe "Pictures without review finder" do
  fixtures :pictures

  it 'should find unreviewed picture' do
    Picture.with_unreviewed_scope {
      Picture.find :all
    }.should include(pictures(:unreviewed))
  end

  it 'should NOT find reviewed pictures' do
    Picture.with_unreviewed_scope {
      Picture.find :all
    }.should_not include(pictures(:reviewed))
  end
end

describe Picture, 'after being marked as appropriate' do
  fixtures :pictures

  it 'should be appropriate' do
    (@pic = pictures(:inappropriate)).should_not be_appropriate
    @pic.appropriate!

    @pic.should be_appropriate
  end
end

describe Picture, 'after being marked as inappropriate' do
  fixtures :pictures

  it 'should be inappropriate' do
    (@pic = pictures(:appropriate)).should be_appropriate
    @pic.inappropriate!
    @pic.should_not be_appropriate
  end

  it 'should NOT be marked inappropriate by user' do
    (@pic = pictures(:user_inappropriate)).should be_user_inappropriate
    @pic.inappropriate!
    @pic.should_not be_user_inappropriate
  end
end

describe 'Appropriate pictures finder' do
  fixtures :pictures

  it 'should find appropriate' do
    Picture.with_appropriate_scope {
      Picture.find :all
    }.should include(pictures(:appropriate))
  end

  it 'should NOT find inappropriate' do
    Picture.with_appropriate_scope {
      Picture.find :all
    }.should_not include(pictures(:inappropriate))
  end
end

describe 'Inappropriate pictures finder' do
  fixtures :pictures

  it 'should find inappropriate' do
    Picture.with_inappropriate_scope {
      Picture.find :all
    }.should include(pictures(:inappropriate))
  end

  it 'should NOT find appropriate' do
    Picture.with_inappropriate_scope {
      Picture.find :all
    }.should_not include(pictures(:appropriate))
  end
end

describe Picture, 'after being marked as appropriated' do
  fixtures :pictures

  before :each do
    @inappropriate      = pictures(:inappropriate)
    @user_inappropriate = pictures(:user_inappropriate)

    Picture.appropriate([@inappropriate, @user_inappropriate])
  end

  it 'should not be found by inappropriate finder' do
    Picture.with_inappropriate_scope do
      Picture.find :all
    end.should_not include(@inappropriate)
  end

  it 'should not be found by user inappropriate finder' do
    Picture.with_user_inappropriate_scope do
      Picture.find :all
    end.should_not include(@user_inappropriate)
  end

  it 'should update review time' do
    @inappropriate.reviewed_at.should be_nil
    @inappropriate.reload # required
    @inappropriate.reviewed_at.should be_kind_of(Time)
  end
end


describe Picture, 'being marked as inappropriate by user' do
  fixtures :pictures

  it 'should become user_inappropriate' do
    (@pic = pictures(:one)).should_not be_user_inappropriate
    @pic.user_inappropriate!
    @pic.should be_user_inappropriate
  end
end

describe Picture, 'being marked as appropriate by user' do
  fixtures :pictures

  it 'should become user_appropriate' do
    (@pic = pictures(:user_inappropriate)).should be_user_inappropriate
    @pic.user_appropriate!
    @pic.should_not be_user_inappropriate
  end
end

describe Picture, 'finding user_inappropriate' do
  fixtures :pictures

  it 'should find user_inappropriate' do
    Picture.with_user_inappropriate_scope {
      Picture.find :all
    }.should include(pictures(:user_inappropriate))
  end

  it 'should not include user_appropriate in found' do
    Picture.with_user_inappropriate_scope {
      Picture.find :all
    }.should_not include(pictures(:user_appropriate))
  end
end

describe 'Hidden images finder' do
  fixtures :pictures

  before :each do
    @hidden = Picture.with_hidden_scope(true) { Picture.find(:all) }
  end

  it 'should include hidden images' do
    @hidden.should include(pictures(:hidden))
  end

  it 'should not include public images' do
    @hidden.should_not include(pictures(:public))
  end
end

describe 'Public images finder' do
  fixtures :pictures

  before :each do
    @pictures = Picture.with_public_scope { Picture.find(:all) }
  end

  it 'should not include hidden pictures' do
    @pictures.should_not include(pictures(:hidden))
  end

  it 'should include appropriate' do
    @pictures.should include(pictures(:appropriate))
  end

  it 'should not include inappropriate' do
    @pictures.should_not include(pictures(:inappropriate))
  end
end