FSharp.Control.TaskSeq/src/FSharp.Control.TaskSeq.Test/TaskSeq.Choose.Tests.fs at 7bbc282af9b063d0f213639ce7f42cfadc7ce915 · fsprojects/FSharp.Control.TaskSeq · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
module TaskSeq.Tests.Choose

open System
open System.Threading.Tasks

open Xunit
open FsUnit.Xunit
open FsToolkit.ErrorHandling

open FSharp.Control

//
// TaskSeq.choose
// TaskSeq.chooseAsync
//

module EmptySeq =
    [<Fact>]
    let ``Null source is invalid`` () =
        assertNullArg
        <| fun () -> TaskSeq.choose (fun _ -> None) null

        assertNullArg
        <| fun () -> TaskSeq.chooseAsync (fun _ -> Task.fromResult None) null

    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
    let ``TaskSeq-choose`` variant = task {
        let! empty =
            Gen.getEmptyVariant variant
            |> TaskSeq.choose (fun _ -> Some 42)
            |> TaskSeq.toListAsync

        List.isEmpty empty |> should be True
    }

    [<Theory; ClassData(typeof<TestEmptyVariants>)>]
    let ``TaskSeq-chooseAsync`` variant = task {
        let! empty =
            Gen.getEmptyVariant variant
            |> TaskSeq.chooseAsync (fun _ -> task { return Some 42 })
            |> TaskSeq.toListAsync

        List.isEmpty empty |> should be True
    }

module Immutable =
    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-choose can convert and filter`` variant = task {
        let chooser number = if number <= 5 then Some(char number + '@') else None
        let ts = Gen.getSeqImmutable variant

        let! letters1 = TaskSeq.choose chooser ts |> TaskSeq.toArrayAsync
        let! letters2 = TaskSeq.choose chooser ts |> TaskSeq.toArrayAsync

        String letters1 |> should equal "ABCDE"
        String letters2 |> should equal "ABCDE"
    }

    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
    let ``TaskSeq-chooseAsync can convert and filter`` variant = task {
        let chooser number = task { return if number <= 5 then Some(char number + '@') else None }
        let ts = Gen.getSeqImmutable variant

        let! letters1 = TaskSeq.chooseAsync chooser ts |> TaskSeq.toArrayAsync
        let! letters2 = TaskSeq.chooseAsync chooser ts |> TaskSeq.toArrayAsync

        String letters1 |> should equal "ABCDE"
        String letters2 |> should equal "ABCDE"
    }

module SideEffects =
    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
    let ``TaskSeq-choose applied multiple times`` variant = task {
        let ts = Gen.getSeqWithSideEffect variant
        let chooser x number = if number <= x then Some(char number + '@') else None

        let! lettersA = ts |> TaskSeq.choose (chooser 5) |> TaskSeq.toArrayAsync
        let! lettersK = ts |> TaskSeq.choose (chooser 15) |> TaskSeq.toArrayAsync
        let! lettersU = ts |> TaskSeq.choose (chooser 25) |> TaskSeq.toArrayAsync

        String lettersA |> should equal "ABCDE"
        String lettersK |> should equal "KLMNO"
        String lettersU |> should equal "UVWXY"
    }

    [<Theory; ClassData(typeof<TestSideEffectTaskSeq>)>]
    let ``TaskSeq-chooseAsync applied multiple times`` variant = task {
        let ts = Gen.getSeqWithSideEffect variant
        let chooser x number = task { return if number <= x then Some(char number + '@') else None }

        let! lettersA = TaskSeq.chooseAsync (chooser 5) ts |> TaskSeq.toArrayAsync
        let! lettersK = TaskSeq.chooseAsync (chooser 15) ts |> TaskSeq.toArrayAsync
        let! lettersU = TaskSeq.chooseAsync (chooser 25) ts |> TaskSeq.toArrayAsync

        String lettersA |> should equal "ABCDE"
        String lettersK |> should equal "KLMNO"
        String lettersU |> should equal "UVWXY"
    }