apply old

sdk/tables/azure-data-tables/pom.xml

@@ -42,6 +42,18 @@ Licensed under the MIT License.
       <artifactId>azure-core</artifactId>
       <version>1.6.0</version> <!-- {x-version-update;com.azure:azure-core;dependency} -->
     </dependency>
+    <dependency>
+      <groupId>com.azure</groupId>
+      <artifactId>azure-storage-common</artifactId>
+      <version>12.7.0-beta.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.8.2</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>

sdk/tables/azure-data-tables/src/test/java/com/azure/data/tables/AzureTablesAsyncClientTest.java

@@ -0,0 +1,134 @@
+package com.azure.data.tables;
+
+import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+
+public class AzureTablesAsyncClientTest {
+    @Test
+    void createTableTest() {
+        // Ideally, we'd use a builder to create this rather than a constructor.
+        AzureTableAsyncClient client = new AzureTableAsyncClient();
+
+        // Every time this variable is used in a downstream subscriber, it will invoke the `createTable` operation.
+        Mono<AzureTable> createTableMono = client.createTable("my-table");
+
+        // This is a subscription to the Mono. `subscribe` is a non-blocking call.
+        createTableMono.subscribe(table -> {
+            System.out.println("Table created is: " + table.getName());
+        }, error -> {
+            System.err.println("There was an error creating the table. " + error);
+        });
+
+        // Since .subscribe is a non-blocking call, after it hooks up the asynchronous operation, it will move
+        // onto the next statement. If `client.createTable` takes 30 seconds, the program would have ended before we
+        // ever know the response because it will leave this method.
+        // You'll see that there is no "System.out.println" console output because the program has ended.
+    }
+
+    /**
+     * Notice how "CREATING TABLE with name: my-table" errors when we try to add another entrythe second time? This is
+     * because, every time we chain the `createTableMono`, it invokes that `createTable` operation again.
+     * After an error occurs in one of the operations upstream in the chain, it will call the (error) -> { } handler.
+     * You'll see that we didn't try to add another entity (ie. new-key-2).
+     *
+     * See {@link #createAndUpdateTableFixed()} for a resolved version.
+     */
+    @Test
+    void createAndUpdateTable() throws InterruptedException {
+        AzureTableAsyncClient client = new AzureTableAsyncClient();
+
+        // Every time this variable is used in a downstream subscriber, it will invoke the `createTable` operation.
+        Mono<AzureTable> createTableMono = client.createTable("my-table");
+
+        // FirstMono -> SecondFlatMap -> Map -> Subscribe
+        createTableMono.flatMap(azureTable -> {
+            // We are chaining another operation to this table creation. We want to use the resulting table and
+            // create an entity in it. We use `flatMap` because it is asynchronous (ie. returns Mono or Flux).
+            Mono<AzureTableEntity> entity = azureTable.createEntity("my-key", "my-value");
+            // We return the `createEntity` operation.
+            return entity;
+        }).map(azureTableEntity -> {
+            // This is a transformation, maybe we only care about the value of that entity we added.
+            return azureTableEntity.getValue();
+        }).subscribe(theValue -> {
+            System.out.println("This was added: " + theValue);
+        }, error -> {
+            System.err.println("Error: " + error);
+        });
+
+        createTableMono.flatMap(azureTable -> {
+            // We are chaining another operation to this table creation. We want to use the resulting table and
+            // create an entity in it. We use `flatMap` because it is asynchronous (ie. returns Mono or Flux).
+            return azureTable.createEntity("my-key-2", "my-value-2");
+        }).map(azureTableEntity -> {
+            // This is a transformation, maybe we only care about the value of that entity we added.
+            return azureTableEntity.getValue();
+        }).subscribe(theValue -> {
+            System.out.println("This was added: " + theValue);
+        }, error -> {
+            System.err.println("Error: " + error);
+        });
+
+        TimeUnit.SECONDS.sleep(20);
+    }
+
+    /**
+     * We've fixed this by caching the result of the `createTable` operation if it is successful. So we don't try to
+     * create the table again.
+     *
+     * See {@link #createAndUpdateTable()}
+     */
+    @Test
+    void createAndUpdateTableFixed() throws InterruptedException {
+        AzureTableAsyncClient client = new AzureTableAsyncClient();
+
+        // Every time this variable is used in a downstream subscriber, it will invoke the `createTable` operation.
+        Mono<AzureTable> createTableMono = client.createTable("my-table")
+            .cache(success -> {
+                System.out.println("--- Table added. Caching value.");
+                return Duration.ofSeconds(Long.MAX_VALUE);
+            }, error -> {
+                System.out.println("--- Error while adding table. Not caching value.");
+                return Duration.ZERO;
+            }, () -> {
+                // This can occur because Monos can output 0 or 1 items. This would be the case where it output 0 items.
+                // For example, Mono.empty() will complete, but not output any items.
+                System.out.println("--- Expected a table to be output, not an empty value. Not caching.");
+                return Duration.ZERO;
+            });
+
+        // FirstMono -> SecondFlatMap -> Map -> Subscribe
+        createTableMono.flatMap(azureTable -> {
+            // We are chaining another operation to this table creation. We want to use the resulting table and
+            // create an entity in it. We use `flatMap` because it is asynchronous (ie. returns Mono or Flux).
+            Mono<AzureTableEntity> entity = azureTable.createEntity("my-new-key", "my-new-value");
+            // We return the `createEntity` operation.
+            return entity;
+        }).map(azureTableEntity -> {
+            // This is a transformation, maybe we only care about the value of that entity we added.
+            return azureTableEntity.getValue();
+        }).subscribe(theValue -> {
+            System.out.println("This was added: " + theValue);
+        }, error -> {
+            System.err.println("ERROR: " + error);
+        });
+
+        createTableMono.flatMap(azureTable -> {
+            // We are chaining another operation to this table creation. We want to use the resulting table and
+            // create an entity in it. We use `flatMap` because it is asynchronous (ie. returns Mono or Flux).
+            return azureTable.createEntity("my-new-key-2", "my-new-value-2");
+        }).map(azureTableEntity -> {
+            // This is a transformation, maybe we only care about the value of that entity we added.
+            return azureTableEntity.getValue();
+        }).subscribe(theValue -> {
+            System.out.println("This was added: " + theValue);
+        }, error -> {
+            System.err.println("ERROR: " + error);
+        });
+
+        TimeUnit.SECONDS.sleep(20);
+    }
+}

sdk/tables/azure-data-tables/src/test/java/com/azure/data/tables/autorestTest.java

@@ -0,0 +1,201 @@
+package com.azure.data.tables;
+
+import com.azure.core.http.*;
+import com.azure.core.http.policy.*;
+
+import com.azure.core.util.Context;
+import com.azure.core.util.logging.ClientLogger;
+import com.azure.data.tables.implementation.AzureTableImpl;
+import com.azure.data.tables.implementation.AzureTableImplBuilder;
+
+import com.azure.data.tables.implementation.TablesImpl;
+import com.azure.data.tables.implementation.models.OdataMetadataFormat;
+import com.azure.data.tables.implementation.models.QueryOptions;
+import com.azure.data.tables.implementation.models.ResponseFormat;
+import com.azure.data.tables.implementation.models.TableProperties;
+import com.azure.storage.common.StorageSharedKeyCredential;
+import com.azure.storage.common.implementation.connectionstring.StorageAuthenticationSettings;
+import com.azure.storage.common.implementation.connectionstring.StorageConnectionString;
+
+import com.azure.storage.common.policy.StorageSharedKeyCredentialPolicy;
+import reactor.test.StepVerifier;
+
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+
+public class autorestTest {
+
+
+    @org.junit.Test
+    void createAndUpdateTableFixed() {
+        final String connectionString = System.getenv("azure_tables_connection_string");
+        final List<HttpPipelinePolicy> policies = new ArrayList<>();
+
+        StorageConnectionString storageConnectionString
+            = StorageConnectionString.create(connectionString, new ClientLogger("tables"));
+
+        StorageAuthenticationSettings authSettings = storageConnectionString.getStorageAuthSettings();
+        StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(authSettings.getAccount().getName(),
+            authSettings.getAccount().getAccessKey());
+
+        //storagesharedkey object and the storage auth object
+        policies.add(new AddDatePolicy());
+        policies.add(new StorageSharedKeyCredentialPolicy(sharedKeyCredential));
+        //HttpLoggingPolicy()
+
+        final HttpPipeline pipeline = new HttpPipelineBuilder()
+            .httpClient(null)
+            .policies(policies.toArray(new HttpPipelinePolicy[0]))
+            .build();
+
+        AzureTableImplBuilder azureTableImplBuilder = new AzureTableImplBuilder();
+        AzureTableImpl azureTable = azureTableImplBuilder
+            .pipeline(pipeline)
+            .url("https://telboytrial.table.core.windows.net/")
+            .buildClient();
+
+        try{
+            TablesImpl tables = azureTable.getTables();
+
+            StepVerifier.create(tables.deleteWithResponseAsync("ebTable","ID23",Context.NONE))
+                .assertNext(response -> {
+                    System.out.println(response);
+                    Assertions.assertEquals(200, response.getStatusCode());
+                })
+                .expectComplete()
+                .verify();
+        } catch (Exception e){
+            System.out.print(e);
+        }
+
+    }
+
+
+    @org.junit.Test
+    void fromConnie () {
+        final List<HttpPipelinePolicy> policies = Arrays.asList(
+            new AddDatePolicy(),
+            new AddHeadersPolicy(new HttpHeaders().put("Accept", OdataMetadataFormat.APPLICATION_JSON_ODATA_MINIMALMETADATA.toString())),
+            new TablesSharedKeyCredentialPolicy(sharedKeyCredential),
+            new HttpLoggingPolicy(new HttpLogOptions()
+                .setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
+        );
+        final HttpPipeline pipeline = new HttpPipelineBuilder()
+            .policies(policies.toArray(new HttpPipelinePolicy[0]))
+            .build();
+        AzureTableImpl azureTable = new AzureTableImplBuilder()
+            .pipeline(pipeline)
+            .version("2019-02-02")
+            .url("https://azsstgt28603173b8764a45.table.core.windows.net/")
+            .buildClient();
+        TableProperties tableProperties = new TableProperties().setTableName("ebTableSeven");
+        QueryOptions queryOptions = new QueryOptions();
+        String requestId = UUID.randomUUID().toString();
+        StepVerifier.create(azureTable.getTables().createWithResponseAsync(tableProperties, requestId,
+            ResponseFormat.RETURN_CONTENT, queryOptions, Context.NONE))
+            .assertNext(response -> {
+                System.out.println(response);
+                Assertions.assertEquals(201, response.getStatusCode());
+            })
+            .expectComplete()
+            .verify();
+    }
+
+
+
+
+    @org.junit.Test
+    void TablesAuth() {
+        final String connectionString = System.getenv("azure_tables_connection_string");
+        final List<HttpPipelinePolicy> policies = new ArrayList<>();
+
+        StorageConnectionString storageConnectionString
+            = StorageConnectionString.create(connectionString, new ClientLogger("tables"));
+        System.out.println(storageConnectionString);
+
+        StorageAuthenticationSettings authSettings = storageConnectionString.getStorageAuthSettings();
+
+        TablesSharedKeyCredential sharedKeyCredential = new TablesSharedKeyCredential(authSettings.getAccount().getName(),
+            authSettings.getAccount().getAccessKey());
+
+        //storagesharedkey object and the storage auth object
+        policies.add(new AddDatePolicy());
+        policies.add(new TablesSharedKeyCredentialPolicy(sharedKeyCredential));
+        policies.add(new HttpLoggingPolicy(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS)));
+        //HttpLoggingPolicy()
+
+        final HttpPipeline pipeline = new HttpPipelineBuilder()
+            .httpClient(null)
+            .policies(policies.toArray(new HttpPipelinePolicy[0]))
+            .build();
+
+        AzureTableImplBuilder azureTableImplBuilder = new AzureTableImplBuilder();
+        AzureTableImpl azureTable = azureTableImplBuilder
+            .pipeline(pipeline)
+            .url("https://telboytrial.table.core.windows.net/")
+            .buildClient();
+
+        try{
+            TablesImpl tables = azureTable.getTables();
+
+            StepVerifier.create(tables.createWithResponseAsync(new TableProperties().setTableName("ebTable"),
+                "ID23",
+                ResponseFormat.RETURN_CONTENT,
+                null,null))
+                .assertNext(response -> {
+                    System.out.println(response);
+                    Assertions.assertEquals(200, response.getStatusCode());
+                })
+                .expectComplete()
+                .verify();
+        } catch (Exception e){
+            System.out.print(e);
+        }
+
+//        try{
+//            TablesImpl tables = azureTable.getTables();
+//
+//            StepVerifier.create(tables.deleteWithResponseAsync("ebTable","ID23",Context.NONE))
+//                .assertNext(response -> {
+//                    System.out.println(response);
+//                    Assertions.assertEquals(200, response.getStatusCode());
+//                })
+//                .expectComplete()
+//                .verify();
+//        } catch (Exception e){
+//            System.out.print(e);
+//        }
+
+    }
+
+
+
+
+
+
+
+
+
+//    @Test
+//    void createTableTest() {
+//        StringToSign = VERB + "\n" +
+//            Content-MD5 + "\n" +
+//            Content-Type + "\n" +
+//            Date + "\n" +
+//            CanonicalizedResource;
+//
+//    }
+//
+//
+//    @Test
+//    void createAndUpdateTable() throws InterruptedException {
+//        TablesImpl ti = new TablesImpl( new AzureTableImpl());
+//        Mono<TablesCreateResponse> c = ti.createWithResponseAsync( new TableProperties(), "requestId", RETURN_CONTENT,
+//            null , new Context("key", "value"));
+//    }
+
+}