mirror of https://github.com/oxen-io/session-ios
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1598 lines
74 KiB
Swift
1598 lines
74 KiB
Swift
// Copyright © 2023 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
import Foundation
|
|
import GRDB
|
|
|
|
import Quick
|
|
import Nimble
|
|
|
|
@testable import SessionUtilitiesKit
|
|
|
|
class JobRunnerSpec: QuickSpec {
|
|
struct TestDetails: Codable {
|
|
enum ResultType: Codable {
|
|
case success
|
|
case failure
|
|
case permanentFailure
|
|
case deferred
|
|
}
|
|
|
|
public let result: ResultType
|
|
public let completeTime: Int
|
|
public let intValue: Int64
|
|
public let stringValue: String
|
|
|
|
init(
|
|
result: ResultType = .success,
|
|
completeTime: Int = 0,
|
|
intValue: Int64 = 100,
|
|
stringValue: String = "200"
|
|
) {
|
|
self.result = result
|
|
self.completeTime = completeTime
|
|
self.intValue = intValue
|
|
self.stringValue = stringValue
|
|
}
|
|
}
|
|
|
|
struct InvalidDetails: Codable {
|
|
func encode(to encoder: Encoder) throws { throw HTTP.Error.parsingFailed }
|
|
}
|
|
|
|
enum TestJob: JobExecutor {
|
|
static let maxFailureCount: Int = 1
|
|
static let requiresThreadId: Bool = false
|
|
static let requiresInteractionId: Bool = false
|
|
|
|
static func run(
|
|
_ job: Job,
|
|
queue: DispatchQueue,
|
|
success: @escaping (Job, Bool, Dependencies) -> (),
|
|
failure: @escaping (Job, Error?, Bool, Dependencies) -> (),
|
|
deferred: @escaping (Job, Dependencies) -> (),
|
|
dependencies: Dependencies
|
|
) {
|
|
guard
|
|
let detailsData: Data = job.details,
|
|
let details: TestDetails = try? JSONDecoder().decode(TestDetails.self, from: detailsData)
|
|
else { return success(job, true, dependencies) }
|
|
|
|
let completeJob: () -> () = {
|
|
// Need to increase the 'completeTime' and 'nextRunTimestamp' to prevent the job
|
|
// from immediately being run again or immediately completing afterwards
|
|
let updatedJob: Job = job
|
|
.with(nextRunTimestamp: TimeInterval(details.completeTime + 1))
|
|
.with(
|
|
details: TestDetails(
|
|
result: details.result,
|
|
completeTime: (details.completeTime + 2),
|
|
intValue: details.intValue,
|
|
stringValue: details.stringValue
|
|
)
|
|
)!
|
|
dependencies.storage.write { db in try _ = updatedJob.saved(db) }
|
|
|
|
switch details.result {
|
|
case .success: success(job, true, dependencies)
|
|
case .failure: failure(job, nil, false, dependencies)
|
|
case .permanentFailure: failure(job, nil, true, dependencies)
|
|
case .deferred: deferred(updatedJob, dependencies)
|
|
}
|
|
}
|
|
|
|
guard dependencies.fixedTime < details.completeTime else { return completeJob() }
|
|
|
|
DispatchQueue.global(qos: .default).async {
|
|
while dependencies.fixedTime < details.completeTime {
|
|
Thread.sleep(forTimeInterval: 0.01) // Wait for 10ms
|
|
}
|
|
|
|
queue.async {
|
|
completeJob()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Spec
|
|
|
|
override func spec() {
|
|
var jobRunner: JobRunnerType!
|
|
var job1: Job!
|
|
var job2: Job!
|
|
var mockStorage: Storage!
|
|
var dependencies: Dependencies!
|
|
|
|
// MARK: - JobRunner
|
|
|
|
describe("a JobRunner") {
|
|
beforeEach {
|
|
mockStorage = Storage(
|
|
customWriter: try! DatabaseQueue(),
|
|
customMigrations: [
|
|
SNUtilitiesKit.migrations()
|
|
]
|
|
)
|
|
dependencies = Dependencies(
|
|
storage: mockStorage,
|
|
date: Date(timeIntervalSince1970: 1234567890)
|
|
)
|
|
|
|
// Migrations add jobs which we don't want so delete them
|
|
mockStorage.write { db in try Job.deleteAll(db) }
|
|
|
|
job1 = Job(
|
|
id: 100,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: nil
|
|
)
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .attachmentUpload,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: nil
|
|
)
|
|
|
|
jobRunner = JobRunner(isTestingJobRunner: true, dependencies: dependencies)
|
|
jobRunner.setExecutor(TestJob.self, for: .messageSend)
|
|
jobRunner.setExecutor(TestJob.self, for: .attachmentUpload)
|
|
jobRunner.setExecutor(TestJob.self, for: .attachmentDownload)
|
|
|
|
// Need to assign this to ensure it's used by nested dependencies
|
|
dependencies.jobRunner = jobRunner
|
|
}
|
|
|
|
afterEach {
|
|
/// We **must** set `fixedTime` to ensure we break any loops within the `TestJob` executor
|
|
dependencies.fixedTime = Int.max
|
|
jobRunner.stopAndClearPendingJobs()
|
|
jobRunner = nil
|
|
mockStorage = nil
|
|
dependencies = nil
|
|
}
|
|
// MARK: -- when configuring
|
|
|
|
context("when configuring") {
|
|
it("adds an executor correctly") {
|
|
job1 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .getSnodePool,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
jobRunner.setExecutor(TestJob.self, for: .getSnodePool)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: -- when managing state
|
|
|
|
context("when managing state") {
|
|
|
|
// MARK: ---- by checking if a job is currently running
|
|
|
|
context("by checking if a job is currently running") {
|
|
it("returns false when not given a job") {
|
|
expect(jobRunner.isCurrentlyRunning(nil)).to(beFalse())
|
|
}
|
|
|
|
it("returns false when given a job that has not been persisted") {
|
|
job1 = Job(variant: .messageSend)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1)).to(beFalse())
|
|
}
|
|
|
|
it("returns false when given a job that is not running") {
|
|
expect(jobRunner.isCurrentlyRunning(job1)).to(beFalse())
|
|
}
|
|
|
|
it("returns true when given a non blocking job that is running") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("returns true when given a blocking job that is running") {
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: true,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job2))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by getting the details for jobs
|
|
|
|
context("by getting the details for jobs") {
|
|
it("returns an empty dictionary when there are no jobs") {
|
|
expect(jobRunner.details()).to(equal([:]))
|
|
}
|
|
|
|
it("returns an empty dictionary when there are no jobs matching the filters") {
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend))
|
|
.toEventually(
|
|
equal([:]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("can filter to specific jobs") {
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
/// The `canStartJob` value needs to be `true` for the job to be added to the queue but as
|
|
/// long as `appDidFinishLaunching` hasn't been called it won't actually start running and
|
|
/// as a result we can test the "pending" state
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Wait for there to be data and the validate the filtering works
|
|
expect(jobRunner.details())
|
|
.toEventuallyNot(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(jobs: [job1])).to(equal([:]))
|
|
expect(jobRunner.detailsFor(jobs: [job2])).to(equal([101: job2.details]))
|
|
}
|
|
|
|
it("can filter to running jobs") {
|
|
job1 = Job(
|
|
id: 100,
|
|
failureCount: 0,
|
|
variant: .attachmentDownload,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .attachmentDownload,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: false,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Wait for there to be data and the validate the filtering works
|
|
expect(jobRunner.detailsFor(state: .running))
|
|
.toEventually(
|
|
equal([100: try! JSONEncoder().encode(TestDetails(completeTime: 1))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(Array(jobRunner.details().keys).sorted()).to(equal([100, 101]))
|
|
}
|
|
|
|
it("can filter to pending jobs") {
|
|
job1 = Job(
|
|
id: 100,
|
|
failureCount: 0,
|
|
variant: .attachmentDownload,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .attachmentDownload,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Wait for there to be data and the validate the filtering works
|
|
expect(jobRunner.detailsFor(state: .pending))
|
|
.toEventually(
|
|
equal([101: try! JSONEncoder().encode(TestDetails(completeTime: 1))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(Array(jobRunner.details().keys).sorted()).to(equal([100, 101]))
|
|
}
|
|
|
|
it("can filter to specific variants") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
job2 = job2.with(details: TestDetails(completeTime: 2))
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Wait for there to be data and the validate the filtering works
|
|
expect(jobRunner.detailsFor(variant: .attachmentUpload))
|
|
.toEventually(
|
|
equal([101: try! JSONEncoder().encode(TestDetails(completeTime: 2))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(Array(jobRunner.details().keys).sorted())
|
|
.toEventually(
|
|
equal([100, 101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("includes non blocking jobs") {
|
|
job2 = job2.with(details: TestDetails(completeTime: 1))
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.detailsFor(state: .running, variant: .attachmentUpload))
|
|
.toEventually(
|
|
equal([101: try! JSONEncoder().encode(TestDetails(completeTime: 1))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("includes blocking jobs") {
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .attachmentUpload,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: true,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try! JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
expect(jobRunner.detailsFor(state: .running, variant: .attachmentUpload))
|
|
.toEventually(
|
|
equal([101: try! JSONEncoder().encode(TestDetails(completeTime: 1))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by checking for an existing job
|
|
|
|
context("by checking for an existing job") {
|
|
it("returns false for a queue that doesn't exist") {
|
|
jobRunner = JobRunner(
|
|
isTestingJobRunner: true,
|
|
variantsToExclude: [.attachmentUpload],
|
|
dependencies: dependencies
|
|
)
|
|
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: TestDetails()))
|
|
.to(beFalse())
|
|
}
|
|
|
|
it("returns false when the provided details fail to decode") {
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: InvalidDetails()))
|
|
.to(beFalse())
|
|
}
|
|
|
|
it("returns false when there is not a pending or running job") {
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: TestDetails()))
|
|
.to(beFalse())
|
|
}
|
|
|
|
it("returns true when there is a pending job") {
|
|
job2 = job2.with(details: TestDetails(completeTime: 1))
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
/// The `canStartJob` value needs to be `true` for the job to be added to the queue but as
|
|
/// long as `appDidFinishLaunching` hasn't been called it won't actually start running and
|
|
/// as a result we can test the "pending" state
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(Array(jobRunner.detailsFor(state: .pending, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: TestDetails(completeTime: 1)))
|
|
.to(beTrue())
|
|
}
|
|
|
|
it("returns true when there is a running job") {
|
|
job2 = job2.with(details: TestDetails(completeTime: 1))
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: TestDetails(completeTime: 1)))
|
|
.to(beTrue())
|
|
}
|
|
|
|
it("returns true when there is a blocking job") {
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .attachmentUpload,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: true,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try! JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: TestDetails(completeTime: 1)))
|
|
.to(beTrue())
|
|
}
|
|
|
|
it("returns true when there is a non blocking job") {
|
|
job2 = job2.with(details: TestDetails(completeTime: 1))
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.hasJob(of: .attachmentUpload, with: TestDetails(completeTime: 1)))
|
|
.to(beTrue())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by being notified of app launch
|
|
|
|
context("by being notified of app launch") {
|
|
it("does not start a job before getting the app launch call") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does nothing if there are no app launch jobs") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("starts the job queues after completing blocking app launch jobs") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 2))
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: true,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try! JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Not currently running
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.isCurrentlyRunning(job2)).to(beFalse())
|
|
|
|
// Make sure it starts
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
// Blocking job running but blocked job not
|
|
expect(jobRunner.isCurrentlyRunning(job2))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.isCurrentlyRunning(job1)).to(beFalse())
|
|
|
|
// Complete 'job2'
|
|
dependencies.fixedTime = 1
|
|
|
|
// Blocked job eventually starts
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("starts the job queues alongside non blocking app launch jobs") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try! JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Not currently running
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure it starts
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.isCurrentlyRunning(job2))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by being notified of app becoming active
|
|
|
|
context("by being notified of app becoming active") {
|
|
it("does not start a job before getting the app active call") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does not start the job queues if there are no app active jobs and blocking jobs are running") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 2))
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: true,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Not currently running
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Start the blocking job
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
// Make sure the other queues don't start
|
|
jobRunner.appDidBecomeActive(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does not start the job queues if there are app active jobs and blocking jobs are running") {
|
|
job1 = Job(
|
|
id: 100,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .recurringOnActive,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 2))
|
|
)
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnceNextLaunch,
|
|
shouldBlock: true,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Not currently running
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Start the blocking queue
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
|
|
// Make sure the other queues don't start
|
|
jobRunner.appDidBecomeActive(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("starts the job queues if there are no app active jobs") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
jobRunner.appDidBecomeActive(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("starts the job queues if there are app active jobs") {
|
|
job1 = Job(
|
|
id: 100,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .recurringOnActive,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
job2 = Job(
|
|
id: 101,
|
|
failureCount: 0,
|
|
variant: .messageSend,
|
|
behaviour: .runOnce,
|
|
shouldBlock: false,
|
|
shouldSkipLaunchBecomeActive: false,
|
|
nextRunTimestamp: 0,
|
|
threadId: nil,
|
|
interactionId: nil,
|
|
details: try? JSONEncoder().encode(TestDetails(completeTime: 1))
|
|
)
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job1,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
jobRunner.upsert(
|
|
db,
|
|
job: job2,
|
|
canStartJob: true,
|
|
dependencies: dependencies
|
|
)
|
|
}
|
|
|
|
// Not currently running
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beFalse(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the queues are started
|
|
jobRunner.appDidBecomeActive(dependencies: dependencies)
|
|
|
|
expect(jobRunner.isCurrentlyRunning(job1))
|
|
.toEventually(
|
|
beTrue(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.isCurrentlyRunning(job2)).to(beTrue())
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: -- when running jobs
|
|
|
|
context("when running jobs") {
|
|
beforeEach {
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
}
|
|
|
|
// MARK: ---- by adding
|
|
|
|
context("by adding") {
|
|
it("does not start until after the db transaction completes") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
jobRunner.add(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
|
|
// Wait for 10ms to give the job the chance to be added
|
|
Thread.sleep(forTimeInterval: 0.01)
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.to(beEmpty())
|
|
}
|
|
|
|
// Wait for 10ms for the job to actually be added
|
|
Thread.sleep(forTimeInterval: 0.01)
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.to(equal([100]))
|
|
}
|
|
}
|
|
// MARK: ---- with dependencies
|
|
|
|
context("with dependencies") {
|
|
it("starts dependencies first") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
job2 = job2.with(details: TestDetails(completeTime: 2))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("removes the initial job from the queue") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 1))
|
|
job2 = job2.with(details: TestDetails(completeTime: 2))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the initial job is removed from the queue
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend).keys).toNot(contain(100))
|
|
}
|
|
|
|
it("starts the initial job when the dependencies succeed") {
|
|
job1 = job1.with(details: TestDetails(completeTime: 2))
|
|
job2 = job2.with(details: TestDetails(completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend).keys).toNot(contain(100))
|
|
|
|
// Make sure the initial job starts
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .messageSend).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does not start the initial job if the dependencies are deferred") {
|
|
job1 = job1.with(details: TestDetails(result: .failure, completeTime: 2))
|
|
job2 = job2.with(details: TestDetails(result: .deferred, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend).keys).toNot(contain(100))
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does not start the initial job if the dependencies fail") {
|
|
job1 = job1.with(details: TestDetails(result: .failure, completeTime: 2))
|
|
job2 = job2.with(details: TestDetails(result: .failure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend).keys).toNot(contain(100))
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does not delete the initial job if the dependencies fail") {
|
|
job1 = job1.with(details: TestDetails(result: .failure, completeTime: 2))
|
|
job2 = job2.with(details: TestDetails(result: .failure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend).keys).toNot(contain(100))
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Stop the queues so it doesn't run out of retry attempts
|
|
jobRunner.stopAndClearPendingJobs(exceptForVariant: nil, onComplete: nil)
|
|
|
|
// Make sure the jobs still exist
|
|
expect(mockStorage.read { db in try Job.fetchCount(db) }).to(equal(2))
|
|
}
|
|
|
|
it("deletes the initial job if the dependencies permanently fail") {
|
|
job1 = job1.with(details: TestDetails(result: .failure, completeTime: 2))
|
|
job2 = job2.with(details: TestDetails(result: .permanentFailure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
try job2.insert(db)
|
|
try JobDependencies(jobId: job1.id!, dependantId: job2.id!).insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
equal([101]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(jobRunner.detailsFor(state: .running, variant: .messageSend).keys).toNot(contain(100))
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running, variant: .attachmentUpload).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the jobs were deleted
|
|
expect(mockStorage.read { db in try Job.fetchCount(db) }).to(equal(0))
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: -- when completing jobs
|
|
|
|
context("when completing jobs") {
|
|
beforeEach {
|
|
jobRunner.appDidFinishLaunching(dependencies: dependencies)
|
|
}
|
|
|
|
// MARK: ---- by succeeding
|
|
|
|
context("by succeeding") {
|
|
it("removes the job from the queue") {
|
|
job1 = job1.with(details: TestDetails(result: .success, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("deletes the job") {
|
|
job1 = job1.with(details: TestDetails(result: .success, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the jobs were deleted
|
|
expect(mockStorage.read { db in try Job.fetchCount(db) }).to(equal(0))
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by deferring
|
|
|
|
context("by deferring") {
|
|
it("reschedules the job to run again later") {
|
|
job1 = job1.with(details: TestDetails(result: .deferred, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(jobRunner.detailsFor(state: .running))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
expect(mockStorage.read { db in try Job.select(.details).asRequest(of: Data.self).fetchOne(db) })
|
|
.to(equal(try! JSONEncoder().encode(TestDetails(result: .deferred, completeTime: 3))))
|
|
}
|
|
|
|
it("does not delete the job") {
|
|
job1 = job1.with(details: TestDetails(result: .deferred, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(jobRunner.detailsFor(state: .running))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the jobs were deleted
|
|
expect(mockStorage.read { db in try Job.fetchCount(db) }).toNot(equal(0))
|
|
}
|
|
|
|
it("fails the job if it is deferred too many times") {
|
|
job1 = job1.with(details: TestDetails(result: .deferred, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure it runs
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Progress the time
|
|
dependencies.fixedTime = 2
|
|
|
|
// Make sure it finishes once
|
|
expect(jobRunner.detailsFor(state: .running))
|
|
.toEventually(
|
|
equal([100: try! JSONEncoder().encode(TestDetails(result: .deferred, completeTime: 3))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
dependencies.fixedTime = 3
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Progress the time
|
|
dependencies.fixedTime = 4
|
|
|
|
// Make sure it finishes twice
|
|
expect(jobRunner.detailsFor(state: .running))
|
|
.toEventually(
|
|
equal([100: try! JSONEncoder().encode(TestDetails(result: .deferred, completeTime: 5))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
dependencies.fixedTime = 5
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Progress the time
|
|
dependencies.fixedTime = 6
|
|
|
|
// Make sure it's finishes the last time
|
|
expect(jobRunner.detailsFor(state: .running))
|
|
.toEventually(
|
|
equal([100: try! JSONEncoder().encode(TestDetails(result: .deferred, completeTime: 7))]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
dependencies.fixedTime = 7
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the job was marked as failed
|
|
expect(mockStorage.read { db in try Job.fetchOne(db, id: 100)?.failureCount }).to(equal(1))
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by failing
|
|
|
|
context("by failing") {
|
|
it("removes the job from the queue") {
|
|
job1 = job1.with(details: TestDetails(result: .failure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("does not delete the job") {
|
|
job1 = job1.with(details: TestDetails(result: .failure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the jobs were deleted
|
|
expect(mockStorage.read { db in try Job.fetchCount(db) }).toNot(equal(0))
|
|
}
|
|
}
|
|
|
|
// MARK: ---- by permanently failing
|
|
|
|
context("by permanently failing") {
|
|
it("removes the job from the queue") {
|
|
job1 = job1.with(details: TestDetails(result: .permanentFailure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
}
|
|
|
|
it("deletes the job") {
|
|
job1 = job1.with(details: TestDetails(result: .permanentFailure, completeTime: 1))
|
|
|
|
mockStorage.write { db in
|
|
try job1.insert(db)
|
|
|
|
jobRunner.upsert(db, job: job1, canStartJob: true, dependencies: dependencies)
|
|
}
|
|
|
|
// Make sure the dependency is run
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
equal([100]),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure there are no running jobs
|
|
dependencies.fixedTime = 1
|
|
expect(Array(jobRunner.detailsFor(state: .running).keys))
|
|
.toEventually(
|
|
beEmpty(),
|
|
timeout: .milliseconds(50)
|
|
)
|
|
|
|
// Make sure the jobs were deleted
|
|
expect(mockStorage.read { db in try Job.fetchCount(db) }).to(equal(0))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|