fix: add RIOE testcases

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>

context/readerioeither/file/file.go

@@ -29,10 +29,9 @@ import (
 )
 
 var (
-	openIOE = IOE.Eitherize1(os.Open)
 	// Open opens a file for reading within the given context
 	Open = F.Flow3(
-		openIOE,
+		IOEF.Open,
 		RIOE.FromIOEither[*os.File],
 		RIOE.WithContext[*os.File],
 	)
@@ -46,11 +45,11 @@ var (
 
 // Close closes an object
 func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
-	return RIOE.FromIOEither(func() ET.Either[error, any] {
-		return ET.TryCatchError(func() (any, error) {
-			return c, c.Close()
-		})
-	})
+	return F.Pipe2(
+		c,
+		IOEF.Close[C],
+		RIOE.FromIOEither[any],
+	)
 }
 
 // ReadFile reads a file in the scope of a context

context/readerioeither/file/tempfile_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package file
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWithTempFile(t *testing.T) {
+
+	res := WithTempFile(onWriteAll[*os.File]([]byte("Carsten")))
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res(context.Background())())
+}
+
+func TestWithTempFileOnClosedFile(t *testing.T) {
+
+	res := WithTempFile(func(f *os.File) RIOE.ReaderIOEither[[]byte] {
+		return F.Pipe2(
+			f,
+			onWriteAll[*os.File]([]byte("Carsten")),
+			RIOE.ChainFirst(F.Constant1[[]byte](Close(f))),
+		)
+	})
+
+	assert.Equal(t, E.Of[error]([]byte("Carsten")), res(context.Background())())
+}

context/readerioeither/file/write.go

@@ -0,0 +1,57 @@
+// Copyright (c) 2023 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package file
+
+import (
+	"context"
+	"io"
+
+	RIOE "github.com/IBM/fp-go/context/readerioeither"
+	F "github.com/IBM/fp-go/function"
+)
+
+func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte] {
+	return func(w W) RIOE.ReaderIOEither[[]byte] {
+		return F.Pipe1(
+			RIOE.TryCatch(func(ctx context.Context) func() ([]byte, error) {
+				return func() ([]byte, error) {
+					_, err := w.Write(data)
+					return data, err
+				}
+			}),
+			RIOE.WithContext[[]byte],
+		)
+	}
+}
+
+// WriteAll uses a generator function to create a stream, writes data to it and closes it
+func WriteAll[W io.WriteCloser](data []byte) func(acquire RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
+	onWrite := onWriteAll[W](data)
+	return func(onCreate RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
+		return RIOE.WithResource[[]byte](
+			onCreate,
+			Close[W])(
+			onWrite,
+		)
+	}
+}
+
+// Write uses a generator function to create a stream, writes data to it and closes it
+func Write[R any, W io.WriteCloser](acquire RIOE.ReaderIOEither[W]) func(use func(W) RIOE.ReaderIOEither[R]) RIOE.ReaderIOEither[R] {
+	return RIOE.WithResource[R](
+		acquire,
+		Close[W])
+}

context/readerioeither/reader.go

@@ -155,6 +155,10 @@ func FromIO[A any](t IO.IO[A]) ReaderIOEither[A] {
 	return G.FromIO[ReaderIOEither[A]](t)
 }
 
+func FromLazy[A any](t L.Lazy[A]) ReaderIOEither[A] {
+	return G.FromIO[ReaderIOEither[A]](t)
+}
+
 // Never returns a 'ReaderIOEither' that never returns, except if its context gets canceled
 func Never[A any]() ReaderIOEither[A] {
 	return G.Never[ReaderIOEither[A]]()

context/readerioeither/reader_test.go

@@ -162,3 +162,125 @@ func TestRegularApply(t *testing.T) {
 	res := applied(context.Background())()
 	assert.Equal(t, E.Of[error]("CARSTEN"), res)
 }
+
+func TestWithResourceNoErrors(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	acquire := FromLazy(func() int {
+		countAcquire++
+		return countAcquire
+	})
+
+	release := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countRelease++
+			return countRelease
+		})
+	}
+
+	body := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countBody++
+			return countBody
+		})
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 1, countAcquire)
+	assert.Equal(t, 1, countBody)
+	assert.Equal(t, 1, countRelease)
+	assert.Equal(t, E.Of[error](1), res)
+}
+
+func TestWithResourceErrorInBody(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	acquire := FromLazy(func() int {
+		countAcquire++
+		return countAcquire
+	})
+
+	release := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countRelease++
+			return countRelease
+		})
+	}
+
+	err := fmt.Errorf("error in body")
+	body := func(int) ReaderIOEither[int] {
+		return Left[int](err)
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 1, countAcquire)
+	assert.Equal(t, 0, countBody)
+	assert.Equal(t, 1, countRelease)
+	assert.Equal(t, E.Left[int](err), res)
+}
+
+func TestWithResourceErrorInAcquire(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	err := fmt.Errorf("error in acquire")
+	acquire := Left[int](err)
+
+	release := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countRelease++
+			return countRelease
+		})
+	}
+
+	body := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countBody++
+			return countBody
+		})
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 0, countAcquire)
+	assert.Equal(t, 0, countBody)
+	assert.Equal(t, 0, countRelease)
+	assert.Equal(t, E.Left[int](err), res)
+}
+
+func TestWithResourceErrorInRelease(t *testing.T) {
+	var countAcquire, countBody, countRelease int
+
+	acquire := FromLazy(func() int {
+		countAcquire++
+		return countAcquire
+	})
+
+	err := fmt.Errorf("error in release")
+	release := func(int) ReaderIOEither[int] {
+		return Left[int](err)
+	}
+
+	body := func(int) ReaderIOEither[int] {
+		return FromLazy(func() int {
+			countBody++
+			return countBody
+		})
+	}
+
+	resRIOE := WithResource[int](acquire, release)(body)
+
+	res := resRIOE(context.Background())()
+
+	assert.Equal(t, 1, countAcquire)
+	assert.Equal(t, 1, countBody)
+	assert.Equal(t, 0, countRelease)
+	assert.Equal(t, E.Left[int](err), res)
+}