user_spec.rb

    describe "#clear_account!" do
      it 'resets the password to a random string' do
        random_pass = "12345678909876543210"
        expect(SecureRandom).to receive(:hex).and_return(random_pass)
        @user.clear_account!
        @user.valid_password?(random_pass)
      end

      it 'clears all the clearable fields' do
        @user.reload
        attributes = @user.send(:clearable_fields)
        @user.clear_account!

        @user.reload
        attributes.each do |attr|
          expect(@user.send(attr.to_sym)).to be_blank
        end
      end

      it 'disables mail' do
        @user.disable_mail = false
        @user.clear_account!
        expect(@user.reload.disable_mail).to be true
      end

      it 'sets getting_started and show_community_spotlight_in_stream fields to false' do
        @user.clear_account!
        expect(@user.reload.getting_started).to be false
        expect(@user.reload.show_community_spotlight_in_stream).to be false
      end
    end

    describe "#clearable_attributes" do
      it 'returns the clearable fields' do
        user = FactoryGirl.create :user
        expect(user.send(:clearable_fields).sort).to eq(%w{
          language
          invitation_token
          invitation_sent_at
          reset_password_sent_at
          reset_password_token
          remember_created_at
          sign_in_count
          current_sign_in_at
          last_sign_in_at
          current_sign_in_ip
          hidden_shareables
          last_sign_in_ip
          invitation_service
          invitation_identifier
          invitation_limit
          invited_by_id
          invited_by_type
          authentication_token
          auto_follow_back
          auto_follow_back_aspect_id
          unconfirmed_email
          confirm_email_token
          last_seen
        }.sort)
      end
    end
  end

  describe "queue_export" do
    it "queues up a job to perform the export" do
      user = FactoryGirl.create :user
      expect(Workers::ExportUser).to receive(:perform_async).with(user.id)
      user.queue_export
      expect(user.exporting).to be_truthy
    end
  end

  describe "perform_export!" do
    it "saves a json export to the user" do
      user = FactoryGirl.create :user, exporting: true
      user.perform_export!
      expect(user.export).to be_present
      expect(user.exported_at).to be_present
      expect(user.exporting).to be_falsey
      expect(user.export.filename).to match /.json/
      expect(ActiveSupport::Gzip.decompress(user.export.file.read)).to include user.username
    end

    it "compresses the result" do
      user = FactoryGirl.create :user, exporting: true
      expect(ActiveSupport::Gzip).to receive :compress
      user.perform_export!
    end
  end

  describe "queue_export_photos" do
    it "queues up a job to perform the export photos" do
      user = FactoryGirl.create :user
      expect(Workers::ExportPhotos).to receive(:perform_async).with(user.id)
      user.queue_export_photos
      expect(user.exporting_photos).to be_truthy
    end
  end

  describe "perform_export_photos!" do
    before do
      @user = alice
      filename  = 'button.png'
      image = File.join(File.dirname(__FILE__), '..', 'fixtures', filename)
      @saved_image = @user.build_post(:photo, :user_file => File.open(image), :to => alice.aspects.first.id)
      @saved_image.save!
    end

    it "saves a zip export to the user" do
      @user.perform_export_photos!
      expect(@user.exported_photos_file).to be_present
      expect(@user.exported_photos_at).to be_present
      expect(@user.exporting_photos).to be_falsey
      expect(@user.exported_photos_file.filename).to match /.zip/
      expect(Zip::File.open(@user.exported_photos_file.path).entries.count).to eq(1)
    end

    it "does not add empty entries when photo not found" do
      File.unlink @user.photos.first.unprocessed_image.path
      @user.perform_export_photos!
      expect(@user.exported_photos_file.filename).to match /.zip/
      expect(Zip::File.open(@user.exported_photos_file.path).entries.count).to eq(0)
    end
  end

  describe "sign up" do
    before do
      params = {:username => "ohai",
                :email => "ohai@example.com",
                :password => "password",
                :password_confirmation => "password",
                :captcha => "12345",

                :person =>
                  {:profile =>
                    {:first_name => "O",
                     :last_name => "Hai"}
                  }
      }
      @user = User.build(params)
    end

    it "saves with captcha off" do
      AppConfig.settings.captcha.enable = false
      expect(@user).to receive(:save).and_return(true)
      @user.sign_up
    end

    it "saves with captcha on" do
      AppConfig.settings.captcha.enable = true
      expect(@user).to receive(:save_with_captcha).and_return(true)
      @user.sign_up
    end
  end

  describe "maintenance" do
    before do
      @user = bob
      AppConfig.settings.maintenance.remove_old_users.enable = true
    end

    it "#flags user for removal" do
      remove_at = Time.now+5.days
      @user.flag_for_removal(remove_at)
      expect(@user.remove_after).to eq(remove_at)
    end
  end

  describe "#auth database auth maintenance" do
    before do
      @user = bob
      @user.remove_after = Time.now
      @user.save
    end

    it "remove_after is cleared" do
      @user.after_database_authentication
      expect(@user.remove_after).to eq(nil)
    end
  end

  describe "active" do
    before do
      invited_user = FactoryGirl.build(:user, username: nil)
      invited_user.save(validate: false)

      closed_account = FactoryGirl.create(:user)
      closed_account.person.closed_account = true
      closed_account.save
    end

    it "returns total_users excluding closed accounts & users without usernames" do
      expect(User.active.count).to eq 6     # 6 users from fixtures
    end
  end
end